Aggiungere l'autenticazione all'app Android

Androide
Cordova
Ios
Windows
Xamarin.Android
Xamarin.Forms
Xamarin.iOS

Sommario

In questa esercitazione si aggiunge l'autenticazione al progetto todolist quickstart su Android tramite un provider di identità compatibile. Questa esercitazione si basa sull'esercitazione Introduzione alle app per dispositivi mobili , che è necessario completare per prima.

Registrare l'app per l'autenticazione e configurare il servizio app di Azure

Prima di tutto, è necessario registrare l'app nel sito di un provider di identità e quindi impostare le credenziali generate dal provider nel back-end delle app per dispositivi mobili.

Configurare il provider di identità preferito seguendo le istruzioni specifiche del provider:
Ripetere i passaggi precedenti per ogni provider che si vuole supportare nell'app.

Aggiungere l'app agli URL di reindirizzamento esterni consentiti

Per l'autenticazione sicura è necessario definire un nuovo schema URL per l'app. Ciò consente al sistema di autenticazione di tornare all'app al termine del processo di autenticazione. In questa esercitazione viene usato lo schema URL nomeapp in tutto. Tuttavia, è possibile usare qualsiasi schema url scelto. Deve essere univoco per l'applicazione per dispositivi mobili. Per abilitare il reindirizzamento sul lato server:

Nel portale di Azure, selezionare il Servizio App.
Fare clic sull'opzione di menu Autenticazione/autorizzazione.
Nella URL di reindirizzamento esterno consentita, inserire appname://easyauth.callback. Il nome app in questa stringa è lo schema URL per l'applicazione per dispositivi mobili. Deve seguire la normale specifica url per un protocollo (usare solo lettere e numeri e iniziare con una lettera). È consigliabile prendere nota della stringa scelta perché sarà necessario modificare il codice dell'applicazione per dispositivi mobili con lo schema URL in diverse posizioni.
Fare clic su OK.
Fare clic su Salva.

Limitare le autorizzazioni agli utenti autenticati

Per impostazione predefinita, le API in un back-end delle app per dispositivi mobili possono essere richiamate in modo anonimo. Successivamente, è necessario limitare l'accesso solo ai client autenticati.

Node.js back-end (tramite il portale di Azure) :

Nelle impostazioni delle app per dispositivi mobili fare clic su Tabelle semplici e selezionare la tabella. Fare clic su Modifica autorizzazioni, selezionare Solo accesso autenticato per tutte le autorizzazioni e quindi fare clic su Salva.
back end .NET (C#):

Nel progetto server, navigare verso Controllers>TodoItemController.cs. Aggiungere l'attributo [Authorize] alla classe TodoItemController come indicato di seguito. Per limitare l'accesso solo a metodi specifici, è anche possibile applicare questo attributo solo a tali metodi anziché alla classe . Ripubblica il progetto del server.
```
  [Authorize]
  public class TodoItemController : TableController<TodoItem>
```
Node.js back-end (tramite codice Node.js) :

Per richiedere l'autenticazione per l'accesso alle tabelle, aggiungere la riga seguente allo script del server Node.js:
```
  table.access = 'authenticated';
```
Per altre informazioni, vedere Procedura: Richiedere l'autenticazione per l'accesso alle tabelle. Per informazioni su come scaricare il progetto di codice di avvio rapido dal sito, vedere Procedura: Scaricare il progetto di codice di avvio rapido back-end Node.js usando Git.

In Android Studio aprire il progetto completato con l'esercitazione Introduzione alle app per dispositivi mobili. Dal menu Esegui fare clic su Esegui app e verificare che venga generata un'eccezione non gestita con un codice di stato 401 (Non autorizzato) dopo l'avvio dell'app.

Questa eccezione si verifica perché l'app tenta di accedere al back-end come utente non autenticato, ma la tabella TodoItem richiede ora l'autenticazione.

Aggiornare quindi l'app per autenticare gli utenti prima di richiedere risorse dal back-end di App per dispositivi mobili.

Aggiungere l'autenticazione all'app

Aprire il progetto in Android Studio.

In Esplora progetti in Android Studio aprire il ToDoActivity.java file e aggiungere le istruzioni import seguenti:

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;

Aggiungere il metodo seguente alla classe 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");
            }
        }
    }
}

Questo codice crea un metodo per gestire il processo di autenticazione di Google. In una finestra di dialogo viene visualizzato l'ID dell'utente autenticato. È possibile procedere solo con un'autenticazione riuscita.

Nota

Se si usa un provider di identità diverso da Google, modificare il valore passato al metodo di accesso in uno dei valori seguenti: MicrosoftAccount, Facebook, Twitter o windowsazureactivedirectory.

Nel metodo onCreate aggiungere la riga di codice seguente dopo il codice che crea un'istanza dell'oggetto MobileServiceClient .
```
authenticate();
```
Questa chiamata avvia il processo di autenticazione.

Spostare il codice rimanente dopo authenticate(); nel metodo onCreate in un nuovo metodo 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();
}

Per assicurarsi che il reindirizzamento funzioni come previsto, aggiungere il frammento di codice seguente di RedirectUrlActivity a 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>

Aggiungi redirectUriScheme alla build.gradle della tua applicazione Android.

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

Aggiungere com.android.support:customtabs:23.0.1 alle dipendenze in build.gradle:

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

Scegliere Esegui app dal menu Esegui per avviare l'app e accedere con il provider di identità scelto.

Avvertimento

Lo schema URL indicato fa distinzione tra maiuscole e minuscole. Assicurarsi che tutte le occorrenze di {url_scheme_of_you_app} usino lo stesso formato di maiuscole e minuscole.

Dopo aver eseguito l'accesso, l'app deve essere eseguita senza errori e dovrebbe essere possibile eseguire query sul servizio back-end e apportare aggiornamenti ai dati.

Memorizzare nella cache i token di autenticazione nel client

L'esempio precedente ha mostrato un accesso standard, che richiede al client di contattare sia il provider di identità che il servizio di Azure back-end ogni volta che viene avviata l'app. Questo metodo è inefficiente ed è possibile avere problemi relativi all'utilizzo se molti clienti tentano di avviare l'app contemporaneamente. Un approccio migliore consiste nel memorizzare nella cache il token di autorizzazione restituito dal servizio di Azure e provare a usarlo prima di usare un accesso basato su provider.

Nota

È possibile memorizzare nella cache il token rilasciato dal servizio di Azure back-end indipendentemente dal fatto che si usi l'autenticazione gestita dal client o gestita dal servizio. Questa esercitazione utilizza l'autenticazione gestita dal servizio.

Aprire il file ToDoActivity.java e aggiungere le istruzioni import seguenti:

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

Aggiungere i membri seguenti alla ToDoActivity classe .

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

Nel file ToDoActivity.java aggiungere la definizione seguente per il cacheUserToken metodo .
```
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();
}
```
Questo metodo archivia l'ID utente e il token in un file di preferenza contrassegnato come privato. Questo deve proteggere l'accesso alla cache in modo che altre app nel dispositivo non abbiano accesso al token. La preferenza è sandbox per l'app. Tuttavia, se un utente ottiene l'accesso al dispositivo, è possibile che ottenga l'accesso alla cache dei token tramite altri mezzi.

Nota

È possibile proteggere ulteriormente il token con la crittografia, se l'accesso del token ai dati è considerato molto sensibile e qualcuno possa ottenere accesso al dispositivo. Una soluzione completamente sicura esula dall'ambito di questa esercitazione, tuttavia, e dipende dai requisiti di sicurezza.

Nel file ToDoActivity.java aggiungere la definizione seguente per il loadUserTokenCache metodo .

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

Nel file ToDoActivity.java sostituire i authenticate metodi e onActivityResult con quelli seguenti, che usano una cache dei token. Modificare il provider di accesso se si vuole usare un account diverso da 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");
            }
        }
    }
}

Compilare l'app e testare l'autenticazione usando un account valido. Eseguirlo almeno due volte. Durante la prima esecuzione, si riceverà un prompt per accedere e creare la cache dei token. Successivamente, ogni esecuzione tenta di caricare la cache dei token per l'autenticazione. Non dovresti essere obbligato a eseguire l'accesso.

Passaggi successivi

Dopo aver completato questa esercitazione sull'autenticazione di base, è consigliabile continuare con una delle esercitazioni seguenti:

Aggiungere notifiche push all'app Android. Informazioni su come configurare il back-end delle app per dispositivi mobili per usare hub di notifica di Azure per inviare notifiche push.
Abilitare la sincronizzazione offline per l'app Android. Informazioni su come aggiungere il supporto offline all'app usando un back-end di App per dispositivi mobili. Con la sincronizzazione offline, gli utenti possono interagire con un'app per dispositivi mobili, visualizzando, aggiungendo o modificando i dati, anche quando non è presente alcuna connessione di rete.

Last updated on 2019-06-25

Condividi tramite