Hinzufügen der Authentifizierung zu Ihrer Android-App

Artikel
06/25/2019

Zusammenfassung

In diesem Tutorial verwenden Sie einen unterstützten Identitätsanbieter, um dem Aufgabenlisten-Schnellstartprojekt unter Android eine Authentifizierung hinzuzufügen. Dieses Tutorial baut auf dem Tutorial Erste Schritte mit mobilen Apps auf, das Sie zuerst abschließen müssen.

Registrieren Ihrer App für die Authentifizierung und Konfigurieren von Azure App Service

Zuerst müssen Sie Ihre App auf der Website eines Identitätsanbieters registrieren und anschließend die vom Anbieter generierten Anmeldeinformationen im Mobile Apps-Back-End festlegen.

Konfigurieren Sie Ihren bevorzugten Identitätsanbieter anhand der anbieterspezifischen Anweisungen:
Wiederholen Sie die oben stehenden Schritte für jeden Anbieter, den Sie in Ihrer App unterstützen möchten.

Hinzufügen Ihrer App zu den zulässigen externen Umleitungs-URLs

Eine sichere Authentifizierung erfordert, dass Sie ein neues URL-Schema für Ihre App definieren. Dies ermöglicht dem Authentifizierungssystem die erneute Umleitung an Ihre App, sobald der Authentifizierungsprozess abgeschlossen ist. In diesem Tutorial verwenden wir ausschließlich das URL-Schema appname. Sie können jedoch ein beliebiges URL-Schema auswählen und verwenden. Es sollte für Ihre mobile Anwendung eindeutig sein. So aktivieren Sie die Umleitung auf der Serverseite

Wählen Sie im Azure-Portal App Service aus.
Klicken Sie auf die Menüoption Authentifizierung/Autorisierung.
Geben Sie in Zulässige externe Umleitungs-URLsappname://easyauth.callback ein. Das appname-Element in dieser Zeichenfolge ist das URL-Schema für Ihre mobile Anwendung. Es sollte der normalen URL-Spezifikation für ein Protokoll folgen (nur aus Buchstaben und Zahlen bestehen und mit einem Buchstaben beginnen). Notieren Sie sich die gewählte Zeichenfolge, da Sie später Ihren mobilen Anwendungscode mehrfach mit dem URL-Schema anpassen müssen.
Klicken Sie auf OK.
Klicken Sie auf Speichern.

Einschränken von Berechtigungen für authentifizierte Benutzer

Standardmäßig können APIs auf Mobile Apps-Back-Ends anonym aufgerufen werden. Als Nächstes müssen Sie den Zugriff auf authentifizierte Clients beschränken.

Node.js-Back-End (über das Azure-Portal):

Klicken Sie in den Einstellungen von Mobile Apps auf Einfache Tabellen, und wählen Sie Ihre Tabelle aus. Klicken Sie auf Berechtigungen ändern, wählen Sie für alle Berechtigungen Authenticated access only (Nur authentifizierter Zugriff) aus, und klicken Sie auf Speichern.
.NET-Back-End (C#):

Navigieren Sie im Serverprojekt zu ControllersTodoItemController.cs>. Fügen Sie das [Authorize]-Attribut der TodoItemController-Klasse wie folgt hinzu: Um den Zugriff auf bestimmte Methoden zu beschränken, können Sie dieses Attribut auch nur auf diese Methoden anstelle der Klasse anwenden. Veröffentlichen Sie das Serverprojekt erneut.
```
  [Authorize]
  public class TodoItemController : TableController<TodoItem>
```
Node.js-Back-End (über Node.js-Code) :

Um für den Zugriff auf Tabellen eine Authentifizierung anzufordern, fügen Sie die folgende Zeile in das Node.js-Serverskript ein:
```
  table.access = 'authenticated';
```
Ausführlichere Informationen finden Sie unter Erzwingen der Authentifizierung für den Zugriff auf Tabellen. Informationen zum Herunterladen des Schnellstart-Codeprojekts von Ihrer Website finden Sie unter Herunterladen des Schnellstart-Codeprojekts für das Node.js-Back-End mithilfe von Git.

Öffnen Sie in Android Studio das Projekt, das Sie im Tutorial Erste Schritte mit mobilen Apps erstellt haben. Klicken Sie im Menü Ausführen auf App ausführen. Vergewissern Sie sich, dass nach dem Start der App ein Ausnahmefehler mit dem Statuscode 401 (nicht autorisiert) ausgelöst wird.

Diese Ausnahme wird ausgelöst, weil die App als nicht authentifizierter Benutzer versucht, auf das Back-End zuzugreifen, aber die TodoItem-Tabelle nun eine Authentifizierung erfordert.

Aktualisieren Sie nun die App, um Benutzer vor dem Anfordern von Ressourcen des Mobile Apps-Back-Ends zu authentifizieren.

Hinzufügen von Authentifizierung zur App

Öffnen Sie das Projekt in Android Studio.

Öffnen Sie die Datei ToDoActivity.java im Projektexplorer in Android Studio, und fügen Sie die folgenden Importanweisungen hinzu:

import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

import com.microsoft.windowsazure.mobileservices.authentication.MobileServiceAuthenticationProvider;
import com.microsoft.windowsazure.mobileservices.authentication.MobileServiceUser;

Fügen Sie der ToDoActivity -Klasse die folgende Methode hinzu:

// You can choose any unique number here to differentiate auth providers from each other. Note this is the same code at login() and onActivityResult().
public static final int GOOGLE_LOGIN_REQUEST_CODE = 1;

private void authenticate() {
    // Sign in using the Google provider.
    mClient.login(MobileServiceAuthenticationProvider.Google, "{url_scheme_of_your_app}", GOOGLE_LOGIN_REQUEST_CODE);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // When request completes
    if (resultCode == RESULT_OK) {
        // Check the request code matches the one we send in the login request
        if (requestCode == GOOGLE_LOGIN_REQUEST_CODE) {
            MobileServiceActivityResult result = mClient.onActivityResult(data);
            if (result.isLoggedIn()) {
                // sign-in succeeded
                createAndShowDialog(String.format("You are now signed in - %1$2s", mClient.getCurrentUser().getUserId()), "Success");
                createTable();
            } else {
                // sign-in failed, check the error message
                String errorMessage = result.getErrorMessage();
                createAndShowDialog(errorMessage, "Error");
            }
        }
    }
}

Dieser Code erstellt eine Methode für die Verarbeitung des Google-Authentifizierungsprozesses. Ein Dialogfeld zeigt die ID des authentifizierten Benutzers an. Sie können den Vorgang nur bei erfolgreicher Authentifizierung fortsetzen.

Hinweis

Falls Sie einen anderen Identitätsanbieter als Google verwenden, ändern Sie den an die login-Methode übergebenen Wert in einen der folgenden Werte: MicrosoftAccount, Facebook, Twitter oder windowsazureactivedirectory.

Fügen Sie in der onCreate-Methode die folgende Codezeile im Anschluss an den Code hinzu, der das MobileServiceClient-Objekt instanziiert.
```
authenticate();
```
Dieser Aufruf startet den Authentifizierungsprozess.

Verschieben Sie den verbleibenden Code nach authenticate(); in der onCreate-Methode in eine neue createTable-Methode :

private void createTable() {

    // Get the table instance to use.
    mToDoTable = mClient.getTable(ToDoItem.class);

    mTextNewToDo = (EditText) findViewById(R.id.textNewToDo);

    // Create an adapter to bind the items with the view.
    mAdapter = new ToDoItemAdapter(this, R.layout.row_list_to_do);
    ListView listViewToDo = (ListView) findViewById(R.id.listViewToDo);
    listViewToDo.setAdapter(mAdapter);

    // Load the items from Azure.
    refreshItemsFromTable();
}

Fügen Sie den folgenden Codeausschnitt von RedirectUrlActivity der Datei AndroidManifest.xml hinzu, um sicherzustellen, dass die Umleitung erwartungsgemäß funktioniert:

<activity android:name="com.microsoft.windowsazure.mobileservices.authentication.RedirectUrlActivity">
    <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="{url_scheme_of_your_app}"
            android:host="easyauth.callback"/>
    </intent-filter>
</activity>

Fügen Sie redirectUriScheme dem build.gradle Ihrer Android-Anwendung hinzu.

android {
    buildTypes {
        release {
            // ...
            manifestPlaceholders = ['redirectUriScheme': '{url_scheme_of_your_app}://easyauth.callback']
        }
        debug {
            // ...
            manifestPlaceholders = ['redirectUriScheme': '{url_scheme_of_your_app}://easyauth.callback']
        }
    }
}

Fügen Sie com.android.support:customtabs:23.0.1 den Abhängigkeiten in Ihrem build.gradle hinzu:
```
dependencies {
    // ...
    compile 'com.android.support:customtabs:23.0.1'
}
```
Klicken Sie im Menü Ausführen auf App ausführen, um die App zu starten, und melden Sie sich mit dem Identitätsanbieter Ihrer Wahl an.

Warnung

Bei dem erwähnten URL-Schema muss die Groß-/Kleinschreibung beachtet werden. Stellen Sie sicher, dass alle Vorkommen von {url_scheme_of_you_app} die gleiche Groß-/Kleinschreibung verwenden.

Nach erfolgreicher Anmeldung sollte die App ohne Fehler ausgeführt werden, und Sie sollten in der Lage sein, den Back-End-Dienst abzufragen und Daten zu aktualisieren.

Zwischenspeichern von Authentifizierungstoken auf dem Client

Im vorhergehenden Beispiel wurde eine Standardanmeldung gezeigt, bei der der Client bei jedem Start der App sowohl den Identitätsanbieter als auch den Azure-Back-End-Dienst kontaktieren muss. Diese Methode ist allerdings ineffizient und kann zu Problemen bei der Nutzung führen, wenn viele Kunden die App gleichzeitig starten möchten. Daher empfiehlt es sich, das vom Azure-Dienst zurückgegebene Authentifizierungstoken zwischenzuspeichern und vor einer anbieterbasierten Anmeldung zu verwenden.

Hinweis

Für die Zwischenspeicherung des vom Azure-Back-End-Dienst zurückgegebenen Authentifizierungstokens spielt es keine Rolle, ob Sie die clientverwaltete oder die dienstverwaltete Authentifizierung verwenden. In diesem Lernprogramm wird die dienstverwaltete Authentifizierung verwendet.

Öffnen Sie die Datei "ToDoActivity.java", und fügen Sie die folgenden import-Anweisungen ein:

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

Fügen Sie die folgenden Mitglieder zur ToDoActivity -Klasse hinzu:

public static final String SHAREDPREFFILE = "temp";
public static final String USERIDPREF = "uid";
public static final String TOKENPREF = "tkn";

Fügen Sie der Datei „ToDoActivity.java“ die folgende Definition für die cacheUserToken-Methode hinzu.
```
private void cacheUserToken(MobileServiceUser user)
{
    SharedPreferences prefs = getSharedPreferences(SHAREDPREFFILE, Context.MODE_PRIVATE);
    Editor editor = prefs.edit();
    editor.putString(USERIDPREF, user.getUserId());
    editor.putString(TOKENPREF, user.getAuthenticationToken());
    editor.commit();
}
```
Diese Methode speichert die Benutzer-ID und das Token in einer als privat gekennzeichneten Einstellungsdatei. Dadurch wird der Zugriff auf den Cache geschützt, sodass andere Apps auf dem Gerät nicht auf das Token zugreifen können. Die Einstellung ist für die App in einer Sandbox isoliert. Trotzdem ist es möglich, dass jemand, der Zugriff auf das Gerät erlangt hat, auf andere Weise auf den Tokencache zugreift.

Hinweis

Falls es sich um besonders sensible Daten handelt und die Gefahr besteht, dass andere Benutzer auf das Gerät zugreifen, können Sie das Token zu seinem Schutz zusätzlich verschlüsseln. Eine absolut sichere Lösung geht allerdings über den Rahmen dieses Tutorial hinaus und hängt zudem von Ihren Sicherheitsanforderungen ab.

Fügen Sie der Datei „ToDoActivity.java“ die folgende Definition für die loadUserTokenCache-Methode hinzu.

private boolean loadUserTokenCache(MobileServiceClient client)
{
    SharedPreferences prefs = getSharedPreferences(SHAREDPREFFILE, Context.MODE_PRIVATE);
    String userId = prefs.getString(USERIDPREF, null);
    if (userId == null)
        return false;
    String token = prefs.getString(TOKENPREF, null);
    if (token == null)
        return false;

    MobileServiceUser user = new MobileServiceUser(userId);
    user.setAuthenticationToken(token);
    client.setCurrentUser(user);

    return true;
}

Ersetzen Sie in der Datei ToDoActivity.java die Methoden authenticate und onActivityResult durch die folgenden, die einen Tokencache verwenden. Wechseln Sie den Login-Anbieter, wenn Sie ein anderes Konto als Google verwenden möchten.

private void authenticate() {
    // We first try to load a token cache if one exists.
    if (loadUserTokenCache(mClient))
    {
        createTable();
    }
    // If we failed to load a token cache, sign in and create a token cache
    else
    {
        // Sign in using the Google provider.
        mClient.login(MobileServiceAuthenticationProvider.Google, "{url_scheme_of_your_app}", GOOGLE_LOGIN_REQUEST_CODE);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // When request completes
    if (resultCode == RESULT_OK) {
        // Check the request code matches the one we send in the sign-in request
        if (requestCode == GOOGLE_LOGIN_REQUEST_CODE) {
            MobileServiceActivityResult result = mClient.onActivityResult(data);
            if (result.isLoggedIn()) {
                // sign-in succeeded
                createAndShowDialog(String.format("You are now signed in - %1$2s", mClient.getCurrentUser().getUserId()), "Success");
                cacheUserToken(mClient.getCurrentUser());
                createTable();
            } else {
                // sign-in failed, check the error message
                String errorMessage = result.getErrorMessage();
                createAndShowDialog(errorMessage, "Error");
            }
        }
    }
}

Erstellen Sie die App und testen Sie die Authentifizierung mit einem gültigen Konto. Führen Sie sie mindestens zweimal aus. Bei der ersten Ausführung sollten Sie eine Aufforderung zur Anmeldung und Erstellung des Tokencaches erhalten. Danach wird bei jeder Ausführung versucht, den Tokencache für die Authentifizierung zu laden. Nun sollte keine Anmeldung mehr erforderlich sein.

Nächste Schritte

Nachdem Sie dieses einfache Tutorial zur Authentifizierung abgeschlossen haben, können Sie mit den folgenden Tutorials fortfahren:

Hinzufügen von Pushbenachrichtigungen zu Ihrer Android-App: Hier erfahren Sie, wie Sie Ihr Mobile Apps-Back-End für die Verwendung von Azure Notification Hubs zum Senden von Pushbenachrichtigungen konfigurieren.
Aktivieren der Offlinesynchronisierung für Ihre Android-App: Hier erfahren Sie, wie Sie die Offlineunterstützung mit einem Mobile Apps-Back-End zu Ihrer App hinzufügen. Mit der Offlinesynchronisierung können Benutzer mit einer mobilen App interagieren ( Anzeigen, Hinzufügen oder Ändern von Daten), auch wenn keine Netzwerkverbindung besteht.

Freigeben über