Lägga till autentisering i din Android-app

2019-06-25

Sammanfattning

I den här handledningen lägger du till autentisering i "todolist"-snabbstartsprojektet på Android med hjälp av en stödd identitetsleverantör. Den här självstudien baseras på självstudien Kom igång med Mobile Apps , som du måste slutföra först.

Registrera din app för autentisering och konfigurera Azure App Service

Först måste du registrera din app på en identitetsproviders webbplats, och sedan anger du de providergenererade autentiseringsuppgifterna i mobile apps-serverdelen.

Konfigurera din önskade identitetsprovider genom att följa de providerspecifika anvisningarna:
Upprepa föregående steg för varje leverantör som du vill stödja i din app.

Lägg till din app i URL:erna för tillåten extern omdirigering

Säker autentisering kräver att du definierar ett nytt URL-schema för din app. Detta gör att autentiseringssystemet kan omdirigera tillbaka till din app när autentiseringsprocessen är klar. I den här självstudien använder vi URL-schemat appname genomgående. Du kan dock använda valfritt URL-schema som du väljer. Den bör vara unik för ditt mobilprogram. Så här aktiverar du omdirigeringen på serversidan:

I Azure-portalen väljer du din App Service.
Klicka på menyalternativet Autentisering/auktorisering .
I URL:er för tillåten extern omdirigering anger du appname://easyauth.callback. Appnamnet i den här strängen är URL-schemat för ditt mobilprogram. Den bör följa normal URL-specifikation för ett protokoll (använd endast bokstäver och siffror och börja med en bokstav). Du bör anteckna strängen som du väljer eftersom du måste justera din mobilprogramkod med URL-schemat på flera platser.
Klicka på OK.
Klicka på Spara.

Begränsa behörigheter till autentiserade användare

Som standard kan API:er i en Mobile Apps-serverdel anropas anonymt. Därefter måste du begränsa åtkomsten till endast autentiserade klienter.

Node.js backend (via Azure-portalen) :

I inställningarna för Mobilappar klickar du på Enkla tabeller och väljer tabellen. Klicka på Ändra behörigheter, välj Endast autentiserad åtkomst för alla behörigheter och klicka sedan på Spara.
.NET-backend (C#):

I serverprojektet navigerar du till Controllers>TodoItemController.cs. [Authorize] Lägg till attributet i klassen TodoItemController enligt följande. Om du bara vill begränsa åtkomsten till specifika metoder kan du även använda det här attributet bara för dessa metoder i stället för klassen. Återpublicera serverprojektet.
```
  [Authorize]
  public class TodoItemController : TableController<TodoItem>
```
Node.js backend (via Node.js kod) :

Om du vill kräva autentisering för tabellåtkomst lägger du till följande rad i Node.js-serverskriptet:
```
  table.access = 'authenticated';
```
Mer information finns i Så här: Kräv autentisering för åtkomst till tabeller. Information om hur du laddar ned snabbstartskodprojektet från din webbplats finns i Så här laddar du ned snabbstartskodprojektet Node.js serverdel med Git.

I Android Studio öppnar du projektet som du slutförde med självstudien Kom igång med Mobile Apps. På kör-menyn klickar du på Kör app och kontrollerar att ett ohanterat undantag med statuskoden 401 (obehörig) aktiveras när appen startar.

Det här undantaget inträffar eftersom appen försöker komma åt serverdelen som en oautentiserad användare, men tabellen TodoItem kräver nu autentisering.

Sedan uppdaterar du appen för att autentisera användare innan du begär resurser från mobile apps-serverdelen.

Lägga till autentisering i appen

Öppna projektet i Android Studio.

Öppna filen i Project Explorer i Android Studio ToDoActivity.java och lägg till följande importinstruktioner:

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;

Lägg till följande metod i klassen ToDoActivity :

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

Den här koden skapar en metod för att hantera Google-autentiseringsprocessen. En dialogruta visar ID för den autentiserade användaren. Du kan bara fortsätta med en lyckad autentisering.

Anmärkning

Om du använder en annan identitetsprovider än Google ändrar du värdet som skickas till inloggningsmetoden till något av följande värden: MicrosoftAccount, Facebook, Twitter eller windowsazureactivedirectory.

I metoden onCreate lägger du till följande kodrad efter koden som instansierar MobileServiceClient objektet.
```
authenticate();
```
Det här anropet startar autentiseringsprocessen.

Flytta den återstående koden efter authenticate(); i metoden onCreate till en ny createTable-metod :

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ör att säkerställa att omdirigeringen fungerar som förväntat lägger du till följande kodfragment i RedirectUrlActivityAndroidManifest.xml:

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

Lägg till build.gradle i redirectUriScheme ditt Android-program.

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

Lägg till com.android.support:customtabs:23.0.1 till beroenden i dina build.gradle:

dependencies {
    // ...
    compile 'com.android.support:customtabs:23.0.1'
}

På menyn Kör klickar du på Kör app för att starta appen och logga in med din valda identitetsprovider.

Varning

Url-schemat som nämns är skiftlägeskänsligt. Se till att alla förekomster av {url_scheme_of_you_app} använder samma fall.

När du har loggat in bör appen köras utan fel och du bör kunna köra frågor mot serverdelstjänsten och göra uppdateringar av data.

Cachelagrar autentiseringstoken på klienten

I föregående exempel visades en standardinloggning som kräver att klienten kontaktar både identitetsprovidern och serverdelstjänsten i Azure varje gång appen startas. Den här metoden är ineffektiv och du kan ha användningsrelaterade problem om många kunder försöker starta appen samtidigt. En bättre metod är att cachelagra auktoriseringstoken som returneras av Azure-tjänsten och försöka använda detta först innan du använder en inloggning via en leverantör.

Anmärkning

Du kan cachelagra tokenet utfärdat av Azure-tjänstens serverdel oavsett om du använder tjänsthanterad eller klienthanterad autentisering. I den här självstudien används tjänsthanterad autentisering.

Öppna filen ToDoActivity.java och lägg till följande importinstruktioner:

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

Lägg till följande medlemmar i ToDoActivity klassen.

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

I filen ToDoActivity.java lägger du till följande definition för cacheUserToken metoden.
```
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();
}
```
Den här metoden lagrar användar-ID och token i en inställningsfil som är markerad som privat. Detta bör skydda åtkomsten till cachen så att andra appar på enheten inte har åtkomst till token. Inställningen är isolerad för appen. Men om någon får åtkomst till enheten är det möjligt att de kan få åtkomst till tokencachen på annat sätt.

Anmärkning

Du kan ytterligare skydda token med kryptering, om tokenåtkomst till dina data anses vara mycket känslig och någon kan få åtkomst till enheten. En helt säker lösning ligger dock utanför den här självstudiekursen och beror på dina säkerhetskrav.

I filen ToDoActivity.java lägger du till följande definition för loadUserTokenCache metoden.

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

I filen ToDoActivity.java ersätter du authenticate metoderna och onActivityResult med följande, som använder en tokencache. Ändra inloggningsprovidern om du vill använda ett annat konto än Google.

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

Skapa appen och testa autentiseringen med ett giltigt konto. Kör den minst två gånger. Under den första körningen bör du få en uppmaning om att logga in och skapa tokencachen. Därefter försöker varje kör läsa in tokencachen för autentisering. Du bör inte behöva logga in.

Nästa steg

Nu när du har slutfört den här grundläggande autentiseringsguiden kan du överväga att fortsätta till någon av följande självstudier:

Lägg till push-meddelanden i din Android-app. Lär dig hur du konfigurerar mobile apps-serverdelen så att den använder Azure-meddelandehubbar för att skicka push-meddelanden.
Aktivera offlinesynkronisering för din Android-app. Lär dig hur du lägger till offlinestöd till din app med hjälp av en mobile apps-serverdel. Med offlinesynkronisering kan användarna interagera med en mobilapp – visa, lägga till eller ändra data – även om det inte finns någon nätverksanslutning.

Dela via