Lägga till autentisering i din Android-app

  • Artikel

Sammanfattning

I den här självstudien lägger du till autentisering i todolist-snabbstartsprojektet på Android med hjälp av en identitetsprovider som stöds. Den här självstudien baseras på Kom igång med Mobile Apps självstudie, 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 ange de autentiseringsuppgifter som genererats av providern Mobile Apps-backend.

  1. Konfigurera den identitetsprovider du föredrar genom att följa de providerspecifika anvisningarna:

  2. Upprepa föregående steg för varje provider 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-schemats appnamn genomgående. Du kan dock använda val annat URL-schema. Det bör vara unikt för ditt mobilprogram. Så här aktiverar du omdirigeringen på serversidan:

  1. I Azure Portal väljer du App Service.

  2. Klicka på menyalternativet Autentisering/auktorisering .

  3. I Tillåtna externa omdirigerings-URL:er anger du appname://easyauth.callback. Appnamnet i den här strängen är URL-schemat för ditt mobilprogram. Den bör följa den normala URL-specifikationen 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 behöver justera koden för mobilprogram med URL-schemat på flera platser.

  4. Klicka på OK.

  5. Klicka på Spara.

Begränsa behörigheter till autentiserade användare

Som standard kan API:er Mobile Apps en backend anropas anonymt. Därefter behöver du begränsa åtkomsten till endast autentiserade klienter.

  • Node.js (via Azure Portal):

    I inställningarna Mobile Apps 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 ControllersTodoItemController.cs>. Lägg till [Authorize] 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 . Publicera om serverprojektet.

      [Authorize]
  public class TodoItemController : TableController<TodoItem>

  • Node.js (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 Gör så här: Kräv autentisering för åtkomst till tabeller. Information om hur du laddar ned snabbstartskodprojektet från webbplatsen finns i How to: Download the Node.js backend quickstart code project using Git (Så här gör du: Ladda ned kodprojektet för Node.js backend med Git).

  • I Android Studio du det projekt som du slutförde med självstudien Kom igång med Mobile Apps. På menyn Kör klickar du på Kör app och kontrollerar att ett ohanterat undantag med statuskoden 401 (Obehörig) utlöses när appen startar.

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

Därefter uppdaterar du appen för att autentisera användare innan du begär resurser från Mobile Apps backend.

Lägga till autentisering i appen

  1. Öppna projektet i Android Studio.

  2. I Project Explorer Android Studio du filen och ToDoActivity.java lägger till följande importutdrag:

    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;

  3. 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:t för den autentiserade användaren. Du kan bara fortsätta med en lyckad autentisering.

    Anteckning

    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.

  4. I metoden onCreate lägger du till följande kodrad efter koden som instansierar MobileServiceClient objektet.

    authenticate();

    Det här anropet startar autentiseringsprocessen.

  5. 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();
}

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

  7. Lägg redirectUriScheme till i build.gradle för 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']
        }
    }
}

  8. Lägg com.android.support:customtabs:23.0.1 till i beroendena i din build.gradle:

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

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

Varning

Det URL-schema som nämns är case-sensitive. Se till att alla förekomster {url_scheme_of_you_app} av använder samma fall.

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

Cachelagra autentiseringstoken på klienten

I föregående exempel visades en standard-inloggning som kräver att klienten kontaktar både identitetsprovidern och Azure-tjänsten på backend-nivå varje gång appen startar. 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 den auktoriseringstoken som returneras av Azure-tjänsten och försöka använda den först innan du använder en providerbaserad inloggning.

Anteckning

Du kan cachelagra den token som utfärdats av Azure-tjänsten på serversidan oavsett om du använder klient-hanterad eller tjänstbaserad autentisering. I den här självstudien används tjänstbaserad autentisering.

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

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

  2. 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";

  3. 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 sandbox-miljö för appen. Men om någon får åtkomst till enheten är det möjligt att de får åtkomst till tokencachen på annat sätt.

    Anteckning

    Du kan skydda token ytterligare 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 omfånget för den här självstudien och är beroende av dina säkerhetskrav.

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

  5. I filen ToDoActivity.java ersätter du metoderna authenticateonActivityResult och 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");
            }
        }
    }
}

  6. Skapa appen och testa autentiseringen med ett giltigt konto. Kör det 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örning 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 självstudien om autentisering kan du fortsätta till någon av följande självstudier: