Přidání ověřování do aplikace pro Android

Shrnutí

V tomto kurzu přidáte ověřování do projektu rychlého spuštění todolist na platformě Android s využitím podporovaného poskytovatele identity. Tento kurz je založený na kurzu Začínáme s Mobile Apps, který musíte dokončit jako první.

Registrace aplikace pro ověřování a konfigurace služby Azure App Service

Nejprve je potřeba zaregistrovat aplikaci na webu zprostředkovatele identity a pak v back-endu Mobile Apps nastavit přihlašovací údaje vygenerované zprostředkovatelem.

Nakonfigurujte svého upřednostňovaného poskytovatele identity podle pokynů specifických pro poskytovatele:
Opakujte předchozí kroky pro každého poskytovatele, kterého chcete ve své aplikaci podporovat.

Přidání aplikace do povolených adres URL pro externí přesměrování

Zabezpečené ověřování vyžaduje, abyste definovali nové schéma adres URL pro vaši aplikaci. Systém ověření tak může po dokončení ověřovacího procesu přesměrovat zpět k vaší aplikaci. V tomto kurzu používáme schéma adresy URL appname v celém textu. Můžete ale použít libovolné schéma adres URL, které zvolíte. Měla by být jedinečná pro vaši mobilní aplikaci. Povolení přesměrování na straně serveru:

Na webu Azure Portal vyberte svou službu App Service.
Klikněte na možnost Ověřování / Autorizace.
Do povolených adres URL externího přesměrování zadejte appname://easyauth.callback. Appname v tomto řetězci je URL schéma pro vaši mobilní aplikaci. Měl by dodržovat normální specifikaci adresy URL pro protokol (používejte jenom písmena a číslice a začněte písmenem). Měli byste si poznamenat řetězec, který zvolíte, protože budete muset upravit kód mobilní aplikace pomocí schématu adresy URL na několika místech.
Klikněte na OK.
Klikněte na Uložit.

Omezení oprávnění pro ověřené uživatele

Ve výchozím nastavení je možné rozhraní API v back-endu Mobile Apps vyvolat anonymně. Dále je potřeba omezit přístup jenom na ověřené klienty.

Backend Node.js (prostřednictvím portálu Azure):

V nastavení Mobile Apps klikněte na Snadné tabulky a vyberte tabulku. Klepněte na tlačítko Změnit oprávnění, vyberte Ověřený přístup pouze pro všechna oprávnění a potom klepněte na tlačítko Uložit.
.NET backend (C#):

V projektu serveru přejděte na Kontrolery>TodoItemController.cs. Přidejte atribut [Authorize] do třídy TodoItemController následujícím způsobem. Chcete-li omezit přístup pouze na konkrétní metody, můžete tento atribut použít pouze u těchto metod místo třídy. Znovu publikujte projekt serveru.
```
  [Authorize]
  public class TodoItemController : TableController<TodoItem>
```
Node.js zázemí (prostřednictvím Node.js kódu):

Pokud chcete vyžadovat ověřování pro přístup k tabulce, přidejte do skriptu serveru Node.js následující řádek:
```
  table.access = 'authenticated';
```
Další podrobnosti najdete v tématu Postupy: Vyžadování ověřování pro přístup k tabulkám. Informace o tom, jak stáhnout projekt kódu pro rychlý start z webu, můžete najít v tématu Postupy: Stažení projektu kódu rychlého startu Node.js backendu pomocí Gitu.

V Android Studiu otevřete projekt, který jste dokončili v kurzu Začínáme s Mobile Apps. V nabídce Spustit klikněte na Spustit aplikaci a ověřte, že se po spuštění aplikace vyvolá neošetřená výjimka se stavovým kódem 401 (Neautorizováno).

K této výjimce dochází, protože se aplikace pokusí o přístup k back-endu jako neověřený uživatel, ale tabulka TodoItem teď vyžaduje ověření.

Dále aplikaci aktualizujete tak, aby před vyžádáním prostředků z back-endu Mobile Apps ověřila uživatele.

Přidání ověřování do aplikace

Otevřete projekt v Android Studiu.

V Průzkumníku projektů v Android Studiu otevřete ToDoActivity.java soubor a přidejte následující příkazy importu:

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;

Do třídy ToDoActivity přidejte následující metodu:

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

Tento kód vytvoří metodu pro zpracování procesu ověřování Google. V dialogovém okně se zobrazí ID ověřeného uživatele. Můžete pokračovat pouze při úspěšném ověření.

Poznámka:

Pokud používáte jiného zprostředkovatele identity než Google, změňte hodnotu předanou metodě přihlášení na jednu z následujících hodnot: MicrosoftAccount, Facebook, Twitter nebo windowsazureactivedirectory.

V onCreate metoda přidejte následující řádek kódu za kód, který vytvoří instanci objektu MobileServiceClient .
```
authenticate();
```
Toto volání spustí proces ověřování.

Přesuňte zbývající kód za authenticate(); metodu onCreate do nové metody createTable :

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

Pokud chcete zajistit, aby přesměrování fungovalo podle očekávání, přidejte následující fragment kódu RedirectUrlActivity do 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>

Přidejte redirectUriScheme do části build.gradle vaší aplikace pro Android.

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

Přidejte com.android.support:customtabs:23.0.1 do závislostí ve build.gradle:

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

V nabídce Spustit spusťte aplikaci kliknutím na Spustit a přihlaste se pomocí zvoleného zprostředkovatele identity.

Výstraha

Zmíněné schéma URL je citlivé na velikost písmen. Ujistěte se, že všechny výskyty {url_scheme_of_you_app} používají stejný formát.

Po úspěšném přihlášení by aplikace měla běžet bez chyb a měli byste být schopni dotazovat back-endovou službu a aktualizovat data.

Ukládání ověřovacích tokenů do mezipaměti v klientovi

Předchozí příklad ukázal standardní přihlášení, které vyžaduje, aby klient kontaktoval zprostředkovatele identity i back-endovou službu Azure při každém spuštění aplikace. Tato metoda je neefektivní a pokud se mnoho zákazníků pokusí spustit aplikaci současně, můžete mít problémy související s používáním. Lepším přístupem je uložení autorizačního tokenu vráceného službou Azure do mezipaměti a pokuste se ho použít před použitím přihlášení založeného na poskytovateli.

Poznámka:

Token vydaný back-endovou službou Azure můžete ukládat do mezipaměti bez ohledu na to, jestli používáte ověřování spravované klientem nebo spravované službou. V tomto kurzu se používá ověřování spravované službou.

Otevřete soubor ToDoActivity.java a přidejte následující příkazy importu:

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

Přidejte do ToDoActivity třídy následující členy.

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

Do souboru ToDoActivity.java přidejte následující definici metody cacheUserToken .
```
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();
}
```
Tato metoda ukládá ID uživatele a token do souboru předvoleb, který je označený jako soukromý. Tím by se měl chránit přístup k mezipaměti, aby k tokenu neměly přístup jiné aplikace v zařízení. Předvolba je pro aplikaci izolována v sandboxu. Pokud ale někdo získá přístup k zařízení, je možné, že získá přístup k mezipaměti tokenů jiným způsobem.

Poznámka:

Token můžete dále chránit pomocí šifrování, pokud je přístup k vašim datům považován za vysoce citlivý a někdo může získat přístup k zařízení. Zcela bezpečné řešení je nad rámec tohoto kurzu, ale závisí na vašich požadavcích na zabezpečení.

Do souboru ToDoActivity.java přidejte následující definici metody loadUserTokenCache .

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

V souboru ToDoActivity.java nahraďte authenticate a onActivityResult metody následujícími metodami, které používají mezipaměť tokenů. Pokud chcete použít jiný účet než Google, změňte zprostředkovatele přihlášení.

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

Sestavte aplikaci a otestujte ověřování pomocí platného účtu. Spusťte ho alespoň dvakrát. Během prvního spuštění byste měli obdržet výzvu k přihlášení a vytvoření mezipaměti tokenů. Potom se každé spuštění pokusí načíst mezipaměť tokenů pro ověřování. Nemělo by být vyžadováno, abyste se přihlásili.

Další kroky

Teď, když jste dokončili tento základní kurz ověřování, zvažte pokračování v některém z následujících kurzů:

Přidejte push oznámení do své aplikace pro Android Zjistěte, jak nakonfigurovat back-end mobilních aplikací tak, aby používal oznámovací centra Azure k odesílání push oznámení.
Povolit offline synchronizaci pro aplikaci pro Android. Zjistěte, jak do aplikace přidat offline podporu pomocí back-endu Mobile Apps. Při offline synchronizaci můžou uživatelé pracovat s mobilní aplikací – prohlížením, přidáváním nebo úpravou dat – i v případě, že připojení k síti není k dispozici.

Last updated on 2019-06-25

Sdílet prostřednictvím