Hinzufügen der Authentifizierung zu Ihrer Android-App

Zusammenfassung

In dieser Anleitung fügen Sie dem Todolist-Schnellstart-Projekt unter Android mithilfe eines unterstützten Identitätsanbieters Authentifizierung hinzu. Dieses Lernprogramm basiert auf dem Erste Schritte mit mobilen Apps Lernprogramm, 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 dann legen Sie die vom Anbieter generierten Anmeldeinformationen im Back-End für mobile Apps fest.

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

Fügen Sie Ihre App zu den zugelassenen externen Umleitungs-URLs hinzu.

Für die sichere Authentifizierung müssen Sie ein neues URL-Schema für Ihre App definieren. Auf diese Weise kann das Authentifizierungssystem wieder zu Ihrer App umgeleitet werden, sobald der Authentifizierungsprozess abgeschlossen ist. In diesem Lernprogramm verwenden wir das URL-Schema App-Namen. Sie können jedoch jedes von Ihnen ausgewählte URL-Schema verwenden. Es sollte für Ihre mobile Anwendung einzigartig sein. So aktivieren Sie die Umleitung auf der Serverseite:

Wählen Sie im Azure-PortalIhren App-Dienst aus.
Klicken Sie auf die Menüoption Authentifizierung/Autorisierung.
Geben Sie bei den zulässigen externen Umleitungs-URLs, appname://easyauth.callbackein. Der App-Name in dieser Zeichenfolge ist das URL-Schema für Ihre mobile Anwendung. Es sollte die normale URL-Spezifikation für ein Protokoll befolgen (nur Buchstaben und Zahlen verwenden und mit einem Buchstaben beginnen). Notieren Sie sich die Zeichenfolge, die Sie auswählen, da Sie ihren mobilen Anwendungscode an mehreren Stellen mit dem URL-Schema anpassen müssen.
Klicke auf OK.
Klicken Sie auf Speichern.

Einschränken von Berechtigungen für authentifizierte Benutzer

Standardmäßig können APIs in einem Back-End für Mobile Apps anonym aufgerufen werden. Als Nächstes müssen Sie den Zugriff auf authentifizierte Clients einschränken.

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

Klicken Sie in ihren Einstellungen für mobile Apps auf einfache Tabellen, und wählen Sie Ihre Tabelle aus. Klicken Sie auf Berechtigungen ändern, wählen Sie Authentifizierten Zugriff nur für alle Berechtigungen aus, und klicken Sie dann auf Speichern.
.NET-Back-End (C#):

Navigieren Sie im Serverprojekt zu Controllern>TodoItemController.cs. Fügen Sie das attribut [Authorize] wie folgt zur TodoItemController Klasse hinzu. Um den Zugriff nur auf bestimmte Methoden einzuschrä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 Backend (über Node.js Code):

Um die Authentifizierung für den Tabellenzugriff zu erfordern, fügen Sie der Node.js Serverskript die folgende Zeile hinzu:
```
  table.access = 'authenticated';
```
Weitere Informationen finden Sie unter Anleitung: Authentifizierung für den Zugriff auf Tabellen erforderlich machen. Informationen zum Herunterladen des Schnellstartcodeprojekts von Ihrer Website finden Sie unter Anleitung: So laden Sie das Node.js-Backend-Schnellstartcodeprojekt mit Git herunter.

Öffnen Sie in Android Studio das Projekt, das Sie mit dem Lernprogramm abgeschlossen haben, Erste Schritte mit mobilen Apps. Klicken Sie im Menü Ausführen auf App ausführen, und vergewissern Sie sich, dass nach dem Starten der App eine Ausnahme mit dem Statuscode 401 (nicht autorisiert) ausgelöst wird.

Diese Ausnahme tritt auf, da die App versucht, als nicht authentifizierter Benutzer auf das Back-End zuzugreifen, aber die TodoItem- Tabelle erfordert jetzt eine Authentifizierung.

Als Nächstes aktualisieren Sie die App so, dass Benutzer authentifiziert werden, bevor Sie Ressourcen aus dem Back-End mobiler Apps anfordern.

Hinzufügen der Authentifizierung zur App

Öffnen Sie das Projekt in Android Studio.

Öffnen Sie in Project Explorer- in Android Studio die datei ToDoActivity.java, 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 klasse ToDoActivity 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 zum Verarbeiten des Google-Authentifizierungsprozesses. In einem Dialogfeld wird die ID des authentifizierten Benutzers angezeigt. Sie können nur mit einer erfolgreichen Authentifizierung fortfahren.

Hinweis

Wenn Sie einen anderen Identitätsanbieter als Google verwenden, ändern Sie den Wert, der an die Login Methode übergeben wird, in einen der folgenden Werte: MicrosoftAccount, Facebook, Twitteroder windowsazureactivedirectory.

Fügen Sie in der onCreate-Methode die folgende Codezeile nach dem 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();
}

Um sicherzustellen, dass die Umleitung wie erwartet funktioniert, fügen Sie den folgenden Codeausschnitt von RedirectUrlActivity zu AndroidManifest.xmlhinzu:

<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 zu 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 zu den Abhängigkeiten in Ihrem build.gradlehinzu.
```
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 sich mit Ihrem gewählten Identitätsanbieter anzumelden.

Warnung

Das erwähnte URL-Schema ist groß-/kleinschreibungsempfindlich. Stellen Sie sicher, dass alle Vorkommen von {url_scheme_of_you_app} denselben Fall verwenden.

Wenn Sie erfolgreich angemeldet sind, sollte die App ohne Fehler ausgeführt werden, und Sie sollten in der Lage sein, den Back-End-Dienst abzufragen und Aktualisierungen an Daten vorzunehmen.

Cache-Authentifizierungstoken auf dem Client

Im vorherigen 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 ineffizient, und Sie können nutzungsbezogene Probleme haben, wenn viele Kunden versuchen, Ihre App gleichzeitig zu starten. Ein besserer Ansatz besteht darin, das vom Azure-Dienst zurückgegebene Autorisierungstoken zwischenzuspeichern und zuerst zu verwenden, bevor Sie eine anbieterbasierte Anmeldung verwenden.

Hinweis

Sie können das vom Back-End-Azure-Dienst ausgegebene Token zwischenspeichern, unabhängig davon, ob Sie die clientverwaltete oder vom Dienst verwaltete Authentifizierung verwenden. In diesem Lernprogramm wird die vom Dienst verwaltete Authentifizierung verwendet.

Öffnen Sie die datei ToDoActivity.java, und fügen Sie die folgenden Importanweisungen hinzu:

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

Fügen Sie der Klasse ToDoActivity die folgenden Member hinzu.

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

Fügen Sie in 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 Einstellungsdatei, die als privat gekennzeichnet ist. Dadurch sollte der Zugriff auf den Cache geschützt werden, damit andere Apps auf dem Gerät keinen Zugriff auf das Token haben. Die Einstellung ist sandkasten für die App. Wenn jemand jedoch Zugriff auf das Gerät erhält, ist es möglich, dass er zugriff auf den Tokencache auf andere Wege erhält.

Hinweis

Sie können das Token mit Verschlüsselung weiter schützen, wenn der Tokenzugriff auf Ihre Daten als streng vertraulich betrachtet wird und jemand möglicherweise Zugriff auf das Gerät erhält. Eine völlig sichere Lösung liegt jedoch außerhalb des Umfangs dieses Lernprogramms und hängt von Ihren Sicherheitsanforderungen ab.

Fügen Sie in 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 Methoden, die einen Tokencache verwenden. Ändern Sie den Anmeldeanbieter, 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. Während der ersten Ausführung sollten Sie eine Aufforderung zum Anmelden und Erstellen des Tokencaches erhalten. Danach versucht jede Ausführung, den Tokencache für die Authentifizierung zu laden. Sie sollten sich nicht anmelden müssen.

Nächste Schritte

Nachdem Sie dieses Lernprogramm für die Standardauthentifizierung abgeschlossen haben, sollten Sie mit einem der folgenden Lernprogramme fortfahren:

Hinzufügen von Pushbenachrichtigungen zu Ihrer Android-App. Erfahren Sie, wie Sie Ihr Mobile Apps Back-End so konfigurieren, dass Azure-Benachrichtigungshubs zum Senden von Pushbenachrichtigungen verwendet werden.
Offlinesynchronisierung für Ihre Android-Appaktivieren. Erfahren Sie, wie Sie Ihrer App Offlineunterstützung mithilfe eines Back-Ends für mobile Anwendungen hinzufügen. Bei der Offlinesynchronisierung können Benutzer mit einer mobilen App interagieren – Anzeigen, Hinzufügen oder Ändern von Daten – auch wenn keine Netzwerkverbindung vorhanden ist.

Last updated on 2019-06-25

Freigeben über