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

Článek
06/25/2019

Souhrn

V tomto kurzu přidáte ověřování do projektu todolist pro rychlý start v Androidu pomocí podporovaného zprostředkovatele identity. Tento kurz je založený na Začínáme s Mobile Apps, který musíte nejprve dokončit.

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

Nejprve musíte svou aplikaci zaregistrovat na webu zprostředkovatele identity a pak nastavíte přihlašovací údaje generované zprostředkovatelem v Mobile Apps back-endu.

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

Přidání aplikace do adres URL povoleného externího přesměrování

Zabezpečené ověřování vyžaduje, aby bylo pro vaši aplikaci definováno nové schéma adresy URL. Díky tomu může ověřovací systém po dokončení procesu ověřování přesměrovat zpět do vaší aplikace. V tomto kurzu používáme v celém kurzu název aplikace schématu adresy URL. Můžete ale použít libovolné schéma URL, které si zvolíte. Měl by být jedinečný pro vaši mobilní aplikaci. Povolení přesměrování na straně serveru:

V Azure Portal vyberte svou App Service.
Klikněte na možnost nabídky Ověřování / autorizace.
Do pole Povolené externí adresy URL pro přesměrování zadejte appname://easyauth.callback. Appname v tomto řetězci je schéma adresy URL pro vaši mobilní aplikaci. Měl by se řídit normální specifikací adresy URL pro protokol (používejte pouze písmena a číslice a začněte písmenem). Řetězec, který zvolíte, byste si měli poznamenat, protože na několika místech budete muset upravit kód mobilní aplikace pomocí schématu adresy URL.
Klikněte na OK.
Klikněte na Uložit.

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

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

Node.js back-end (prostřednictvím Azure Portal):

V nastavení Mobile Apps klikněte na Snadné tabulky a vyberte tabulku. Klikněte na Změnit oprávnění, u všech oprávnění vyberte Jenom ověřený přístup a pak klikněte na Uložit.
Back-end .NET (C#):

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

Pokud chcete vyžadovat ověřování pro přístup k tabulce, přidejte do skriptu Node.js serveru 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, najdete v tématu Postupy: Stažení projektu kódu Node.js back-endu pomocí Gitu.

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

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 aktualizujete aplikaci tak, aby ověřovat uživatele před vyžádáním prostředků z Mobile Apps back-endu.

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

Otevřete projekt v Android Studio.

V Project Explorer v Android Studio 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 metodě onCreate přidejte za kód, který vytvoří instanci objektu , následující řádek MobileServiceClient kódu.
```
authenticate();
```
Toto volání spustí proces ověřování.

Přesuňte zbývající kód za v authenticate();metodě 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í funguje podle očekávání, přidejte do souboru následující fragment RedirectUrlActivity kódu 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 build.gradle 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í v souboru build.gradle:
```
dependencies {
    // ...
    compile 'com.android.support:customtabs:23.0.1'
}
```
V nabídce Spustit kliknutím na Spustit aplikaci spusťte aplikaci a přihlaste se pomocí zvoleného zprostředkovatele identity.

Upozornění

Uvedené schéma adresy URL rozlišuje velká a malá písmena. Ujistěte se, že všechny výskyty {url_scheme_of_you_app} používají stejný případ.

Po úspěšném přihlášení by se aplikace měla spustit bez chyb a měli byste být schopni dotazovat back-endovou službu a provádět aktualizace dat.

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

Předchozí příklad ukázal standardní přihlášení, které vyžaduje, aby klient při každém spuštění aplikace kontaktoval zprostředkovatele identity i back-endovou službu Azure. 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 využitím. Lepším přístupem je ukládání autorizačního tokenu vráceného službou Azure do mezipaměti a před použitím přihlášení založeného na poskytovateli se ho nejprve pokusit použít.

Poznámka

Token vystavený 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. Tento kurz 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;

Do třídy přidejte následující ToDoActivity č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 uloží ID uživatele a token do souboru předvoleb označeného jako soukromý. Tím by se měl chránit přístup k mezipaměti, aby ostatní aplikace na zařízení neměly přístup k tokenu. Předvolba je pro aplikaci izolovaná v izolovaném prostoru. Pokud ale někdo získá přístup k zařízení, může k mezipaměti tokenů získat přístup jiným způsobem.

Poznámka

Token můžete dál chránit šifrováním, pokud se přístup k vašim datům považuje za vysoce citlivý a někdo může získat přístup k zařízení. Zcela zabezpečené řešení ale přesahuje rozsah tohoto kurzu a 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 authenticateonActivityResult metody a 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. Při prvním spuštění by se měla zobrazit výzva k přihlášení a vytvoření mezipaměti tokenů. Potom se každé spuštění pokusí načíst mezipaměť tokenů pro ověření. Přihlášení by nemělo být povinné.

Další kroky

Teď, když jste dokončili tento kurz základního ověřování, zvažte pokračování k jednomu z následujících kurzů:

Přidání nabízených oznámení do aplikace pro Android Zjistěte, jak nakonfigurovat Mobile Apps back-end, aby k odesílání nabízených oznámení používat centra oznámení Azure.
Povolte pro svou aplikaci pro Android offline synchronizaci. Zjistěte, jak do aplikace přidat podporu offline pomocí Mobile Apps back-endu. Díky offline synchronizaci mohou uživatelé pracovat s mobilní aplikací – prohlížením, přidáváním nebo úpravou dat – i když není k dispozici žádné síťové připojení.

Sdílet prostřednictvím