Aktivieren der Authentifizierung in Ihrer eigenen Android -App mithilfe von Azure AD B2C

In diesem Artikel wird beschrieben, wie Sie einer eigenen mobilen Android-Anwendung die Authentifizierung von Azure Active Directory B2C (Azure AD B2C) hinzufügen.

Verwenden Sie diesen Artikel mit den Informationen unter Konfigurieren der Authentifizierung in einer Android-Beispiel-App mithilfe von Azure AD B2C, und ersetzen Sie dabei die Android-Beispiel-App durch Ihre eigene Android-App. Nachdem Sie die Anleitung in diesem Artikel ausgeführt haben, akzeptiert Ihre Anwendung Anmeldungen über Azure AD B2C.

Voraussetzungen

Berücksichtigen Sie die Voraussetzungen und Integrationsschritte unter Konfigurieren der Authentifizierung in einer Android-Beispielanwendung mithilfe von Azure AD B2C.

Erstellen eines Android-App-Projekts

Falls Sie noch nicht über eine Android-Anwendung verfügen, richten Sie wie folgt ein neues Projekt ein:

1. Wählen Sie in Android Studio Start a new Android Studio project (Neues Android Studio-Projekt starten) aus.
2. Wählen Sie Basic Activity (Standardaktivität) aus, und klicken Sie dann auf Weiter.
3. Benennen Sie Ihre Anwendung.
4. Speichern Sie den Paketnamen. Sie geben diesen später im Azure-Portal ein.
5. Ändern Sie die Sprache von Kotlin in Java.
6. Legen Sie Minimum API level (Mindestebene für API) auf API 19 oder höher fest, und klicken Sie auf Finish (Fertig stellen).
7. Wählen Sie in der Projektansicht in der Dropdownliste die Option Project aus, um die Projektdateien mit und ohne Quelle anzuzeigen, öffnen Sie app/build.gradle, und legen Sie dann targetSdkVersion auf 28 fest.

Schritt 1: Installieren der Abhängigkeiten

Navigieren Sie im Android Studio-Projektfenster zu app>build.gradle, und fügen Sie dann Folgendes hinzu:

apply plugin: 'com.android.application'

allprojects {
    repositories {
    mavenCentral()
    google()
    mavenLocal()
    maven {
        url 'https://pkgs.dev.azure.com/MicrosoftDeviceSDK/DuoSDK-Public/_packaging/Duo-SDK-Feed/maven/v1'
    }
    maven {
        name "vsts-maven-adal-android"
        url "https://identitydivision.pkgs.visualstudio.com/_packaging/AndroidADAL/maven/v1"
        credentials {
            username System.getenv("ENV_VSTS_MVN_ANDROIDADAL_USERNAME") != null ? System.getenv("ENV_VSTS_MVN_ANDROIDADAL_USERNAME") : project.findProperty("vstsUsername")
            password System.getenv("ENV_VSTS_MVN_ANDROIDADAL_ACCESSTOKEN") != null ? System.getenv("ENV_VSTS_MVN_ANDROIDADAL_ACCESSTOKEN") : project.findProperty("vstsMavenAccessToken")
        }
    }
    jcenter()
    }
}
dependencies{
    implementation 'com.microsoft.identity.client:msal:2.+'
    }
packagingOptions{
    exclude("META-INF/jersey-module-version")
}

Schritt 2: Hinzufügen der Authentifizierungskomponenten

Der Beispielcode setzt sich aus den folgenden Komponenten zusammen. Fügen Sie diese Komponenten aus der Android-Beispiel-App Ihrer eigenen App hinzu.

Komponente	type	`Source`	BESCHREIBUNG
B2CUser	Klasse	Kotlin Java	Repräsentiert einen B2C-Benutzer. Diese Klasse ermöglicht es Benutzern, sich mit mehreren Richtlinien anzumelden.
B2CModeFragment	Fragment-Klasse	Kotlin Java	Ein Fragment repräsentiert einen modularen Teil der Anmeldung über die Azure AD B2C-Benutzerschnittstelle in Ihrer Hauptaktivität. Dieses Fragment enthält den Großteil des Authentifizierungscodes.
fragment_b2c_mode.xml	Fragment-Layout	Kotlin Java	Definiert die Struktur für eine Benutzerschnittstelle für die B2CModeFragment-Fragmentkomponente.
B2CConfiguration	Klasse	Kotlin Java	Eine Konfigurationsdatei enthält Informationen zu Ihrem Azure AD B2C-Identitätsanbieter. Die mobile App nutzt diese Informationen, um eine Vertrauensstellung mit Azure AD B2C herzustellen, Benutzer an- und abzumelden sowie Token zu beziehen und zu überprüfen. Weitere Konfigurationseinstellungen finden Sie in der Datei „auth_config_b2c.json“.
auth_config_b2c.json	JSON-Datei	Kotlin Java	Eine Konfigurationsdatei enthält Informationen zu Ihrem Azure AD B2C-Identitätsanbieter. Die mobile App nutzt diese Informationen, um eine Vertrauensstellung mit Azure AD B2C herzustellen, Benutzer an- und abzumelden sowie Token zu beziehen und zu überprüfen. Weitere Konfigurationseinstellungen finden Sie in der B2CConfiguration-Klasse.

Schritt 3: Konfigurieren der Android-App

Nachdem Sie die Authentifizierungskomponenten hinzugefügt haben, konfigurieren Sie Ihre Android-App mit Ihren Azure AD B2C-Einstellungen. Einstellungen für den Azure AD B2C-Identitätsanbieter werden in der Datei auth_config_b2c.json und in der B2CConfiguration-Klasse konfiguriert.

Anweisungen finden Sie unter Konfigurieren der mobilen Beispiel-App.

Schritt 4: Festlegen des Umleitungs-URI

Konfigurieren Sie, wo Ihre Anwendung auf die Azure AD B2C-Tokenantwort lauscht.

1. Generieren Sie einen neuen Signaturhash für die Entwicklung. Dieser lautet für jede Entwicklungsumgebung anders.

   Windows:

   keytool -exportcert -alias androiddebugkey -keystore %HOMEPATH%\.android\debug.keystore | openssl sha1 -binary | openssl base64
   

   Für iOS:

   keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore | openssl sha1 -binary | openssl base64
   

   Verwenden Sie für eine Produktionsumgebung den folgenden Befehl:

   keytool -exportcert -alias SIGNATURE_ALIAS -keystore PATH_TO_KEYSTORE | openssl sha1 -binary | openssl base64
   

   Weitere Hilfe beim Signieren Ihrer Apps finden Sie unter Signieren Ihrer Android-App.

2. Wählen Sie app>src>main>AndroidManifest.xml, und fügen Sie dann die folgende BrowserTabActivity-Aktivität zum Hauptteil der Anwendung hinzu:

   <!--Intent filter to capture System Browser or Authenticator calling back to our app after sign-in-->
   <activity
       android:name="com.microsoft.identity.client.BrowserTabActivity">
       <intent-filter>
           <action android:name="android.intent.action.VIEW" />
           <category android:name="android.intent.category.DEFAULT" />
           <category android:name="android.intent.category.BROWSABLE" />
           <data android:scheme="msauth"
               android:host="Package_Name"
               android:path="/Signature_Hash" />
       </intent-filter>
   </activity>
   

3. Ersetzen Sie Signature_Hash durch den von Ihnen generierten Hash.

4. Ersetzen Sie Package_Name durch den Namen Ihres Android-Pakets.

Gehen Sie folgendermaßen vor, um die Registrierung der mobilen App mit Ihrem App-Umleitungs-URI zu aktualisieren:

1. Melden Sie sich beim Azure-Portal an.
2. Wenn Sie Zugriff auf mehrere Mandanten haben, wählen Sie das Symbol Einstellungen im Menü oben aus, um über das Menü Verzeichnisse + Abonnements zu Ihrem Azure AD B2C-Mandanten zu wechseln.
3. Suchen Sie nach Azure AD B2C, und wählen Sie diese Option aus.
4. Wählen Sie unter App-Registrierungen und dann die Anwendung aus, die Sie in Schritt 2.3: Registrieren der mobilen App registriert haben.
5. Wählen Sie Authentifizierung aus.
6. Wählen Sie unter Android die Option URI hinzufügen aus.
7. Geben Sie Paketname und Signaturhash ein.
8. Wählen Sie Speichern aus.

Ihr Umleitungs-URI und die BrowserTabActivity-Aktivität sollten in etwa wie im folgenden Beispiel aussehen:

Kotlin

Die Umleitungs-URL für das Android-Beispiel sieht folgendermaßen aus:

msauth://com.azuresamples.msalandroidkotlinapp/1wIqXSqBj7w%2Bh11ZifsnqwgyKrY%3D

Der Absichtsfilter verwendet das gleiche Muster wie im folgenden XML-Codeausschnitt:

<activity android:name="com.microsoft.identity.client.BrowserTabActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data
            android:host="com.azuresamples.msalandroidkotlinapp"
            android:path="/1wIqXSqBj7w+h11ZifsnqwgyKrY="
            android:scheme="msauth" />
    </intent-filter>
</activity>

Java

Die Umleitungs-URL für das Android-Beispiel sieht folgendermaßen aus:

msauth://com.azuresamples.msalandroidapp/1wIqXSqBj7w%2Bh11ZifsnqwgyKrY%3D

Der Absichtsfilter verwendet das gleiche Muster wie im folgenden XML-Codeausschnitt:

<activity android:name="com.microsoft.identity.client.BrowserTabActivity">
<intent-filter>
    <action android:name="android.intent.action.VIEW" />

    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />

    <data
        android:host="com.azuresamples.msalandroidapp"
        android:path="/1wIqXSqBj7w+h11ZifsnqwgyKrY="
        android:scheme="msauth" />
</intent-filter>
</activity>

Schritt 5: Anpassen Ihrer Codebausteine

In diesem Abschnitt werden die Codebausteine beschrieben, die Ihrer Android-App die Authentifizierung ermöglichen. In der folgenden Tabelle werden die B2CModeFragment-Methoden aufgeführt, und es wird angegeben, wie Sie Ihren Code anpassen.

Schritt 5.1: Instanziieren einer öffentlichen Clientanwendung

Öffentlichen Clientanwendungen sind nicht vertrauenswürdig genug, um Anwendungsgeheimnisse sicher aufzubewahren, deshalb enthalten sie keine geheimen Clientschlüssel. Instanziieren Sie in onCreate oder onCreateView MSAL mithilfe des Objekts für öffentliche Clientanwendungen, das mehrere Konten umfasst.

Die MultipleAccountPublicClientApplication-Klasse wird verwendet, um MSAL-basierte Apps zu erstellen, die ein gleichzeitiges Anmelden mehrerer Konten zulassen. Die Klasse ermöglicht die Anmeldung mit mehreren Azure AD B2C-Benutzerflows oder benutzerdefinierten Richtlinien. Benutzer melden sich beispielsweise mit einem Benutzerflow für Anmeldung oder Registrierung an und führen später einen Benutzerflow für die Profilbearbeitung aus.

Der folgende Codeausschnitt veranschaulicht die Initialisierung der MSAL-Bibliothek mit der JSON-Konfigurationsdatei auth_config_b2c.json.

Kotlin

PublicClientApplication.createMultipleAccountPublicClientApplication(context!!,
    R.raw.auth_config_b2c,
    object : IMultipleAccountApplicationCreatedListener {
        override fun onCreated(application: IMultipleAccountPublicClientApplication) {
            // Set the MultipleAccountPublicClientApplication to the class member b2cApp
            b2cApp = application
            // Load the account (if there is any)
            loadAccounts()
        }

        override fun onError(exception: MsalException) {
            // Error handling
            displayError(exception)
        }
    })

Java

PublicClientApplication.createMultipleAccountPublicClientApplication(getContext(),
    R.raw.auth_config_b2c,
    new IPublicClientApplication.IMultipleAccountApplicationCreatedListener() {
        @Override
        public void onCreated(IMultipleAccountPublicClientApplication application) {
            // Set the MultipleAccountPublicClientApplication to the class member b2cApp
            b2cApp = application;

            // Load the account (if there is any)
            loadAccounts();
        }

        @Override
        public void onError(MsalException exception) {
            // Error handling
            displayError(exception);
        }
    });

Schritt 5.2: Laden von Konten

Wenn die App in den Vordergrund wechselt, lädt sie das vorhandene Konto, um festzustellen, ob Benutzer angemeldet sind. Verwenden Sie diese Methode, um die Benutzeroberfläche mit dem Authentifizierungsstatus zu aktualisieren. Sie können beispielsweise die Abmeldeschaltfläche aktivieren oder deaktivieren.

Im folgenden Codeausschnitt wird das Laden der Konten veranschaulicht:

Kotlin

private fun loadAccounts() {
    if (b2cApp == null) {
        return
    }
    b2cApp!!.getAccounts(object : LoadAccountsCallback {
        override fun onTaskCompleted(result: List<IAccount>) {
            users = B2CUser.getB2CUsersFromAccountList(result)
            updateUI(users)
        }
    
        override fun onError(exception: MsalException) {
            displayError(exception)
        }
    })
    }

Java

private void loadAccounts() {
    if (b2cApp == null) {
        return;
    }

    b2cApp.getAccounts(new IPublicClientApplication.LoadAccountsCallback() {
        @Override
        public void onTaskCompleted(final List<IAccount> result) {
            users = B2CUser.getB2CUsersFromAccountList(result);
            updateUI(users);
        }

        @Override
        public void onError(MsalException exception) {
            displayError(exception);
        }
    });
}

Schritt 5.3: Starten einer interaktiven Autorisierungsanforderung

Eine interaktive Autorisierungsanforderung ist ein Flow, bei dem Benutzer zur Registrierung oder Anmeldung aufgefordert werden. Die initializeUI-Methode konfiguriert das runUserFlowButton-Klickereignis. Wenn Benutzer auf die Schaltfläche Benutzerflow ausführen klicken, leitet die App sie an Azure AD B2C weiter, um den Anmeldeflow abzuschließen.

Die runUserFlowButton.setOnClickListener-Methode bereitet das Objekt AcquireTokenParameters mit relevanten Daten zur Autorisierungsanforderung vor. Die acquireToken-Methode fordert Benutzer dann auf, den Registrierungs- oder Anmeldeflow abzuschließen.

Der folgende Codeausschnitt veranschaulicht, wie die interaktive Autorisierungsanforderung gestartet wird:

Kotlin

val parameters = AcquireTokenParameters.Builder()
        .startAuthorizationFromActivity(activity)
        .fromAuthority(getAuthorityFromPolicyName(policy_list.getSelectedItem().toString()))
        .withScopes(B2CConfiguration.scopes)
        .withPrompt(Prompt.LOGIN)
        .withCallback(authInteractiveCallback)
        .build()

b2cApp!!.acquireToken(parameters)

Java

AcquireTokenParameters parameters = new AcquireTokenParameters.Builder()
        .startAuthorizationFromActivity(getActivity())
        .fromAuthority(B2CConfiguration.getAuthorityFromPolicyName(policyListSpinner.getSelectedItem().toString()))
        .withScopes(B2CConfiguration.getScopes())
        .withPrompt(Prompt.LOGIN)
        .withCallback(getAuthInteractiveCallback())
        .build();

b2cApp.acquireToken(parameters);

Schritt 5.4: Rückruf für interaktive Autorisierungsanforderung

Sobald die Benutzer den Autorisierungsflow abgeschlossen haben (erfolgreich oder nicht), wird das Ergebnis an die getAuthInteractiveCallback()-Methode zurückgegeben.

Die Rückrufmethode übergibt das AuthenticationResult-Objekt oder eine Fehlermeldung im MsalException-Objekt. Verwenden Sie diese Methode für folgende Aufgaben:

• Aktualisieren der Benutzeroberfläche der mobilen App mit Informationen nach Abschluss der Anmeldung.
• Erneutes Laden des Kontenobjekts.
• Aufrufen eines Web-API-Diensts mit einem Zugriffstoken
• Verarbeiten von Authentifizierungsfehlern.

Der folgende Codeausschnitt veranschaulicht die Verwendung des interaktiven Authentifizierungsrückrufs.

Kotlin

private val authInteractiveCallback: AuthenticationCallback
    private get() = object : AuthenticationCallback {
        override fun onSuccess(authenticationResult: IAuthenticationResult) {
            /* Successfully got a token, use it to call a protected resource; web API  */
            Log.d(TAG, "Successfully authenticated")

            /* display result info */
            displayResult(authenticationResult)

            /* Reload account asynchronously to get the up-to-date list. */
            loadAccounts()
        }

        override fun onError(exception: MsalException) {
            val B2C_PASSWORD_CHANGE = "AADB2C90118"
            if (exception.message!!.contains(B2C_PASSWORD_CHANGE)) {
                txt_log!!.text = """
                    Users click the 'Forgot Password' link in a sign-up or sign-in user flow.
                    Your application needs to handle this error code by running a specific user flow that resets the password.
                    """.trimIndent()
                return
            }

            /* Failed to acquireToken */Log.d(TAG, "Authentication failed: $exception")
            displayError(exception)
            if (exception is MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception is MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            }
        }

        override fun onCancel() {
            /* User canceled the authentication */
            Log.d(TAG, "User cancelled login.")
        }
    }

Java

private AuthenticationCallback getAuthInteractiveCallback() {
    return new AuthenticationCallback() {

        @Override
        public void onSuccess(IAuthenticationResult authenticationResult) {
            /* Successfully got a token, use it to call a protected resource - MSGraph */
            Log.d(TAG, "Successfully authenticated");

            /* display result info */
            displayResult(authenticationResult);

            /* Reload account asynchronously to get the up-to-date list. */
            loadAccounts();
        }

        @Override
        public void onError(MsalException exception) {
            final String B2C_PASSWORD_CHANGE = "AADB2C90118";
            if (exception.getMessage().contains(B2C_PASSWORD_CHANGE)) {
                logTextView.setText("Users click the 'Forgot Password' link in a sign-up or sign-in user flow.\n" +
                        "Your application needs to handle this error code by running a specific user flow that resets the password.");
                return;
            }

            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: " + exception.toString());
            displayError(exception);

            if (exception instanceof MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception instanceof MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            }
        }

        @Override
        public void onCancel() {
            /* User canceled the authentication */
            Log.d(TAG, "User cancelled login.");
        }
    };
}

Schritt 6: Aufrufen einer Web-API

Zum Aufruf einer tokenbasierten Autorisierungs-Web-API benötigt die App ein gültiges Zugriffstoken. Die App führt folgende Schritte aus:

1. Beziehen eines Zugriffstokens mit den erforderlichen Berechtigungen (Bereichen) für den Web-API-Endpunkt
2. Übergeben des Zugriffstokens als Bearertoken im Autorisierungsheader der HTTP-Anforderung in folgendem Format:

Authorization: Bearer <access-token>

Wenn sich Benutzer interaktiv anmelden, empfängt die App ein Zugriffstoken in der getAuthInteractiveCallback-Rückrufmethode. Verwenden Sie für nachfolgende Web-API-Aufrufe das Verfahren zum automatischen Tokenabruf, wie in diesem Abschnitt beschrieben.

Rufen Sie vor dem Aufruf einer Web-API die acquireTokenSilentAsync-Methode mit den geeigneten Bereichen für Ihren Web-API-Endpunkt auf. Die MSAL-Bibliothek führt Folgendes aus:

1. Es wird versucht, ein Zugriffstoken mit den angeforderten Bereichen aus dem Tokencache abzurufen. Falls das Token vorhanden ist, wird es zurückgegeben.
2. Wenn das Token nicht im Tokencache vorhanden ist, versucht die MSAL-Bibliothek, mithilfe des Aktualisierungstokens ein neues Zugriffstoken zu beziehen.
3. Wenn das Aktualisierungstoken nicht vorhanden oder abgelaufen ist, wird eine Ausnahme zurückgegeben. In diesem Fall sollte der Benutzer dazu aufgefordert werden, sich interaktiv anzumelden.

Der folgende Codeausschnitt veranschaulicht das Beziehen eines Zugriffstokens:

Kotlin

Durch das Klickereignis für die acquireTokenSilentButton-Schaltfläche wird ein Zugriffstoken mit den angegebenen Bereichen erworben.

btn_acquireTokenSilently.setOnClickListener(View.OnClickListener {
    if (b2cApp == null) {
        return@OnClickListener
    }
    val selectedUser = users!![user_list.getSelectedItemPosition()]
    selectedUser.acquireTokenSilentAsync(b2cApp!!,
            policy_list.getSelectedItem().toString(),
            B2CConfiguration.scopes,
            authSilentCallback)
})

Die authSilentCallback-Rückrufmethode gibt ein Zugriffstoken zurück und ruft eine Web-API auf:

private val authSilentCallback: SilentAuthenticationCallback
    private get() = object : SilentAuthenticationCallback {
        override fun onSuccess(authenticationResult: IAuthenticationResult) {
            Log.d(TAG, "Successfully authenticated")

            /* Call your web API here*/
            callWebAPI(authenticationResult)
        }

        override fun onError(exception: MsalException) {
            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: $exception")
            displayError(exception)
            if (exception is MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception is MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            } else if (exception is MsalUiRequiredException) {
                /* Tokens expired or no session, retry with interactive */
            }
        }
    }

Das folgende Beispiel veranschaulicht, wie eine geschützte Web-API mit einem Bearertoken aufgerufen wird:

@Throws(java.lang.Exception::class)
private fun callWebAPI(authenticationResult: IAuthenticationResult) {
    val accessToken = authenticationResult.accessToken
    val thread = Thread {
        try {
            val url = URL("https://your-app-service.azurewebsites.net/helo")
            val conn = url.openConnection() as HttpsURLConnection
            conn.setRequestProperty("Accept", "application/json")
            
            // Set the bearer token
            conn.setRequestProperty("Authorization", "Bearer $accessToken")
            if (conn.responseCode == HttpURLConnection.HTTP_OK) {
                val br = BufferedReader(InputStreamReader(conn.inputStream))
                var strCurrentLine: String?
                while (br.readLine().also { strCurrentLine = it } != null) {
                    Log.d(TAG, strCurrentLine)
                }
            }
            conn.disconnect()
        } catch (e: IOException) {
            e.printStackTrace()
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
    thread.start()
}

Java

Durch das Klickereignis für die acquireTokenSilentButton-Schaltfläche wird ein Zugriffstoken mit den angegebenen Bereichen erworben.

acquireTokenSilentButton.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        if (b2cApp == null) {
            return;
        }

        final B2CUser selectedUser = users.get(b2cUserList.getSelectedItemPosition());
        selectedUser.acquireTokenSilentAsync(b2cApp,
                policyListSpinner.getSelectedItem().toString(),
                B2CConfiguration.getScopes(),
                getAuthSilentCallback());
    }
});

Die authSilentCallback-Rückrufmethode gibt ein Zugriffstoken zurück und ruft eine Web-API auf:

private SilentAuthenticationCallback getAuthSilentCallback() {
    return new SilentAuthenticationCallback() {

        @Override
        public void onSuccess(IAuthenticationResult authenticationResult) {
            Log.d(TAG, "Successfully authenticated");

            /* Call your web API here*/
            callWebAPI(authenticationResult);
        }

        @Override
        public void onError(MsalException exception) {
            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: " + exception.toString());
            displayError(exception);

            if (exception instanceof MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception instanceof MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            } else if (exception instanceof MsalUiRequiredException) {
                /* Tokens expired or no session, retry with interactive */
            }
        }
    };
}

Das folgende Beispiel veranschaulicht, wie eine geschützte Web-API mit einem Bearertoken aufgerufen wird:

private void callWebAPI(IAuthenticationResult authenticationResult) throws Exception {
    final String accessToken = authenticationResult.getAccessToken();
    
    
    Thread thread = new Thread(new Runnable() {
    
        @Override
        public void run() {
            try {
                URL url = new URL("https://your-app-service.azurewebsites.net/helo");
                HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
                conn.setRequestProperty("Accept", "application/json");
                
                // Set the bearer token
                conn.setRequestProperty("Authorization", "Bearer " +  accessToken);
    
                if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
                    BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                    String strCurrentLine;
                    while ((strCurrentLine = br.readLine()) != null) {
                        Log.d(TAG, strCurrentLine);
                    }
                }
                conn.disconnect();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
    
    thread.start();
    
    }

Hinzufügen der Berechtigung zum Ausführen von Netzwerkvorgängen

Um Netzwerkvorgänge in Ihrer Anwendung auszuführen, fügen Sie die folgende Berechtigung zu Ihrem Manifest hinzu. Weitere Informationen finden Sie unter Verbindungsherstellung mit dem Netzwerk.

<uses-permission android:name="android.permission.INTERNET"/>

Nächste Schritte

In diesem Artikel werden folgende Themen erläutert:

• Konfigurieren der Authentifizierungsoptionen in einer Android-App mithilfe von Azure AD B2C
• Aktivieren der Authentifizierung in Ihrer eigenen Web-API mit Azure AD B2C