Aggiungere l'autenticazione all'app AndroidAdd authentication to your Android app

SummarySummary

Questa esercitazione spiega come aggiungere l'autenticazione al progetto introduttivo TodoList in Android tramite un provider di identità supportato.In this tutorial, you add authentication to the todolist quickstart project on Android by using a supported identity provider. Questa esercitazione è basata sull'esercitazione Introduzione ad App per dispositivi mobili, che deve essere completata per prima.This tutorial is based on the [Get started with Mobile Apps] tutorial, which you must complete first.

Registrare l'app per l'autenticazione e configurare Servizio app di AzureRegister your app for authentication and configure Azure App Service

Innanzitutto, è necessario registrare l'app nel sito di un provider di identità e quindi impostare le credenziali generate dal provider nel back-end dell'app per dispositivi mobili.First, you need to register your app at an identity provider's site, and then you will set the provider-generated credentials in the Mobile Apps back end.

  1. Configurare il provider di identità preferito seguendo le istruzioni specifiche del provider:Configure your preferred identity provider by following the provider-specific instructions:

  2. Ripetere i passaggi precedenti per ogni provider di cui si desidera il supporto nell'app.Repeat the previous steps for each provider you want to support in your app.

Aggiungere l'app agli URL di reindirizzamento esterni consentitiAdd your app to the Allowed External Redirect URLs

L'autenticazione sicura richiede la definizione di un nuovo schema URL per l'app.Secure authentication requires that you define a new URL scheme for your app. In questo modo il sistema di autenticazione reindirizza all'app al termine del processo di autenticazione.This allows the authentication system to redirect back to your app once the authentication process is complete. In questa esercitazione si usa lo schema URL appname.In this tutorial, we use the URL scheme appname throughout. È tuttavia possibile usare QUALSIASI schema URL.However, you can use any URL scheme you choose. Lo schema deve essere univoco per l'applicazione per dispositivi mobili.It should be unique to your mobile application. Per abilitare il reindirizzamento sul lato server:To enable the redirection on the server side:

  1. Nel portale di Azure selezionare il servizio app.In the [Azure portal], select your App Service.

  2. Fare clic sull'opzione di menu Autenticazione/Autorizzazione.Click the Authentication / Authorization menu option.

  3. In URL di reindirizzamento esterni consentiti specificare appname://easyauth.callback.In the Allowed External Redirect URLs, enter appname://easyauth.callback. Il valore appname in questa stringa è lo schema URL per l'applicazione per dispositivi mobili.The appname in this string is the URL Scheme for your mobile application. Deve seguire le normale specifica URL per un protocollo, ovvero usare solo lettere e numeri e iniziare con una lettera.It should follow normal URL specification for a protocol (use letters and numbers only, and start with a letter). È opportuno prendere nota della stringa scelta perché sarà necessario modificare il codice dell'applicazione per dispositivi mobili con lo schema URL in diverse posizioni.You should make a note of the string that you choose as you will need to adjust your mobile application code with the URL Scheme in several places.

  4. Fare clic su OK.Click OK.

  5. Fare clic su Save.Click Save.

Limitare le autorizzazioni agli utenti autenticatiRestrict permissions to authenticated users

Per impostazione predefinita, le API in un back-end dell'app per dispositivi mobili possono essere richiamate in modo anonimo.By default, APIs in a Mobile Apps back end can be invoked anonymously. È necessario limitare l'accesso solo ai client autenticati.Next, you need to restrict access to only authenticated clients.

  • Back-end Node. js nuovamente fine (tramite il Portale di Azure) :Node.js back end (via the Azure portal) :

    Nelle impostazioni dell'app per dispositivi mobili fare clic su Tabelle semplici e selezionare la tabella.In your Mobile Apps settings, click Easy Tables and select your table. Fare clic su Modifica autorizzazioni, selezionare Authenticated access only (Solo accesso con autenticazione) per tutte le autorizzazioni e quindi fare clic su Salva.Click Change permissions, select Authenticated access only for all permissions, and then click Save.

  • Back-end. NET (C#):.NET back end (C#):

    Nel progetto server passare a Controller > TodoItemController.cs.In the server project, navigate to Controllers > TodoItemController.cs. Aggiungere l'attributo [Authorize] alla classe TodoItemController, come indicato di seguito.Add the [Authorize] attribute to the TodoItemController class, as follows. Per limitare l'accesso solo a metodi specifici, è inoltre possibile applicare questo attributo solo a tali metodi anziché alla classe.To restrict access only to specific methods, you can also apply this attribute just to those methods instead of the class. Pubblicare di nuovo il progetto server.Republish the server project.

      [Authorize]
      public class TodoItemController : TableController<TodoItem>
    
  • Back-end Node.js (tramite codice Node.js) :Node.js backend (via Node.js code) :

    Per richiedere l'autenticazione per l'accesso alla tabella, aggiungere la riga seguente allo script del server Node.js:To require authentication for table access, add the following line to the Node.js server script:

      table.access = 'authenticated';
    

    Per altre informazioni, vedere Procedura: Richiedere l'autenticazione per l'accesso alle tabelle.For more details, see How to: Require authentication for access to tables. Per informazioni su come scaricare il progetto di codice di avvio rapido dal sito, vedere Procedura: Scaricare il progetto di codice di avvio rapido del back-end Node.js tramite Git.To learn how to download the quickstart code project from your site, see How to: Download the Node.js backend quickstart code project using Git.

  • In Android Studio aprire il progetto completato con l'esercitazione Introduzione ad App per dispositivi mobili.In Android Studio, open the project you completed with the tutorial [Get started with Mobile Apps]. Dal menu Run fare clic su Run app e verificare che, dopo l'avvio dell'app, venga generata un'eccezione non gestita con codice di stato 401 (Non autorizzata).From the Run menu, click Run app, and verify that an unhandled exception with a status code of 401 (Unauthorized) is raised after the app starts.

    Questa eccezione viene generata perché l'app tenta di accedere al back-end come utente non autenticato, mentre la tabella TodoItem richiede ora l'autenticazione.This exception happens because the app attempts to access the back end as an unauthenticated user, but the TodoItem table now requires authentication.

A questo punto, si aggiorna l'app in modo che autentichi gli utenti prima di richiedere risorse al back-end di App per dispositivi mobili.Next, you update the app to authenticate users before requesting resources from the Mobile Apps back end.

Aggiungere l'autenticazione all'appAdd authentication to the app

  1. Aprire il progetto in Android Studio.Open the project in Android Studio.

  2. In Project Explorer (Esplora progetti) in Android Studio aprire il file ToDoActivity.java e aggiungere le istruzioni import seguenti:In Project Explorer in Android Studio, open the ToDoActivity.java file and add the following import statements:

    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. Aggiungere il metodo seguente alla classe ToDoActivity :Add the following method to the ToDoActivity class:

    // 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() {
        // Login 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()) {
                    // login succeeded
                    createAndShowDialog(String.format("You are now logged in - %1$2s", mClient.getCurrentUser().getUserId()), "Success");
                    createTable();
                } else {
                    // login 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.This code creates a method to handle the Google authentication process. Una finestra di dialogo riporta l'ID dell'utente autenticato.A dialog displays the ID of the authenticated user. È possibile procedere unicamente se l'autenticazione ha esito positivo.You can only proceed on a successful authentication.

    Nota

    Se si usa un provider di identità diverso da Google, sostituire il valore passato al metodo login con uno dei valori seguenti: MicrosoftAccount, Facebook, Twitter o windowsazureactivedirectory.If you are using an identity provider other than Google, change the value passed to the login method to one of the following values: MicrosoftAccount, Facebook, Twitter, or windowsazureactivedirectory.

  4. Nel metodo onCreate aggiungere la riga di codice seguente dopo il codice che crea un'istanza dell'oggetto MobileServiceClient.In the onCreate method, add the following line of code after the code that instantiates the MobileServiceClient object.

    authenticate();
    

    Questa chiamata avvia il processo di autenticazione.This call starts the authentication process.

  5. Spostare il codice rimanente dopo authenticate(); nel metodo onCreate in un nuovo metodo createTable:Move the remaining code after authenticate(); in the onCreate method to a new createTable method:

    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. Per assicurarsi che il reindirizzamento funzioni come previsto, aggiungere il frammento di RedirectUrlActivity in AndroidManifest.xml:To ensure redirection works as expected, add the following snippet of RedirectUrlActivity to 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. Aggiungere redirectUriScheme in build.gradle dell'applicazione Android.Add redirectUriScheme to build.gradle of your Android application.

    android {
        buildTypes {
            release {
                // ...
                manifestPlaceholders = ['redirectUriScheme': '{url_scheme_of_your_app}://easyauth.callback']
            }
            debug {
                // ...
                manifestPlaceholders = ['redirectUriScheme': '{url_scheme_of_your_app}://easyauth.callback']
            }
        }
    }
    
  8. Aggiungere com.android.support:customtabs:23.0.1 alle dipendenze in build.gradle:Add com.android.support:customtabs:23.0.1 to the dependencies in your build.gradle:

    dependencies {
        // ...
        compile 'com.android.support:customtabs:23.0.1'
    }
    
  9. Scegliere Run app (Esegui app) dal menu Esegui per avviare l'app e accedere con il provider di identità scelto.From the Run menu, click Run app to start the app and sign in with your chosen identity provider.

Avviso

Lo schema URL indicato rispetta la distinzione tra maiuscole e minuscole.The URL Scheme mentioned is case-sensitive. Assicurarsi che tutte le occorrenze di {url_scheme_of_you_app} abbiano le stesse maiuscole e minuscole.Ensure that all occurrences of {url_scheme_of_you_app} use the same case.

Dopo avere eseguito l'accesso, l'app dovrebbe funzionare senza errori e dovrebbe essere possibile eseguire query sul servizio back-end e aggiornare i dati.When you are successfully signed in, the app should run without errors, and you should be able to query the back-end service and make updates to data.

Memorizzare nella cache i token di autenticazione sul clientCache authentication tokens on the client

L'esempio precedente illustra un accesso standard che richiede al client di contattare sia il provider di identità sia il servizio back-end di Azure ogni volta che l'app viene avviata.The previous example showed a standard sign-in, which requires the client to contact both the identity provider and the back-end Azure service every time the app starts. Questo metodo risulta inefficiente e può creare problemi relativi all'uso se più clienti tentano di avviare l'app contemporaneamente.This method is inefficient, and you can have usage-related issues if many customers try to start your app simultaneously. Un miglior approccio consiste nel memorizzare nella cache il token di autorizzazione restituito dal servizio Azure e provare a usarlo prima di un accesso basato su provider.A better approach is to cache the authorization token returned by the Azure service, and try to use this first before using a provider-based sign-in.

Nota

È possibile memorizzare nella cache il token rilasciato dal servizio back-end di Azure indipendentemente dal fatto che si usi l'autenticazione gestita dal client o dal servizio.You can cache the token issued by the back-end Azure service regardless of whether you are using client-managed or service-managed authentication. In questa esercitazione viene usata l'autenticazione gestita dal servizio.This tutorial uses service-managed authentication.

  1. Aprire il file ToDoActivity.java e quindi aggiungere le istruzioni import seguenti:Open the ToDoActivity.java file and add the following import statements:

    import android.content.Context;
    import android.content.SharedPreferences;
    import android.content.SharedPreferences.Editor;
    
  2. Aggiungere i membri seguenti alla classe ToDoActivity :Add the following members to the ToDoActivity class.

    public static final String SHAREDPREFFILE = "temp";
    public static final String USERIDPREF = "uid";
    public static final String TOKENPREF = "tkn";
    
  3. Nel file ToDoActivity.java aggiungere la definizione seguente per il metodo cacheUserToken.In the ToDoActivity.java file, add the following definition for the cacheUserToken method.

    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 consente di memorizzare l'ID utente e il token in un file delle preferenze contrassegnato come privato.This method stores the user ID and token in a preference file that is marked private. In questo modo è possibile proteggere l'accesso alla cache, affinché le altre app sul dispositivo non possano accedere al token.This should protect access to the cache so that other apps on the device do not have access to the token. La preferenza è in modalità sandbox per l'applicazione.The preference is sandboxed for the app. Tuttavia, se qualcuno riesce ad accedere al dispositivo, è possibile che riesca accedere anche alla cache dei token con altri mezzi.However, if someone gains access to the device, it is possible that they may gain access to the token cache through other means.

    Nota

    È possibile proteggere ulteriormente il token con la crittografia se l'accesso token ai dati è considerato altamente sensibile e qualcuno potrebbe accedere al dispositivo.You can further protect the token with encryption, if token access to your data is considered highly sensitive and someone may gain access to the device. Tuttavia, una soluzione del tutto sicura esula dall'ambito di questa esercitazione e dipende dai rispettivi requisiti di sicurezza.A completely secure solution is beyond the scope of this tutorial, however, and depends on your security requirements.

  4. Nel file ToDoActivity.java aggiungere la definizione seguente per il metodo loadUserTokenCache.In the ToDoActivity.java file, add the following definition for the loadUserTokenCache method.

    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. Nel file ToDoActivity.java sostituire i metodi authenticate e onActivityResult con i seguenti, che usano una cache dei token.In the ToDoActivity.java file, replace the authenticate and onActivityResult methods with the following ones, which uses a token cache. Modificare il provider di accesso se si vuole usare un account diverso da Google.Change the login provider if you want to use an account other than 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, login and create a token cache
        else
        {
            // Login 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()) {
                    // login succeeded
                    createAndShowDialog(String.format("You are now logged in - %1$2s", mClient.getCurrentUser().getUserId()), "Success");
                    cacheUserToken(mClient.getCurrentUser());
                    createTable();
                } else {
                    // login failed, check the error message
                    String errorMessage = result.getErrorMessage();
                    createAndShowDialog(errorMessage, "Error");
                }
            }
        }
    }
    
  6. Creare l'app e testare l'autenticazione con un account valido.Build the app and test authentication using a valid account. Eseguirla almeno due volte.Run it at least twice. Durante la prima esecuzione, si riceverà un prompt di accesso per creare la cache dei token.During the first run, you should receive a prompt to sign in and create the token cache. Successivamente, ogni esecuzione tenta di caricare la cache dei token per l'autenticazione.After that, each run attempts to load the token cache for authentication. Non viene richiesto di effettuare l'accesso.You should not be required to sign in.

Passaggi successiviNext steps

Dopo aver completato questa esercitazione sull'autenticazione di base, provare a continuare fino a una delle esercitazioni seguenti:Now that you completed this basic authentication tutorial, consider continuing on to one of the following tutorials:

  • Aggiungere notifiche push all'app Android.Add push notifications to your Android app. Informazioni su come configurare App per dispositivi mobili in modo da utilizzare l'Hub di notifica di Azure per inviare notifiche push.Learn how to configure your Mobile Apps back end to use Azure notification hubs to send push notifications.
  • Attivare la sincronizzazione offline per l'app Android.Enable offline sync for your Android app. Informazioni su come aggiungere il supporto offline all'app usando il back-end di App per dispositivi mobili.Learn how to add offline support to your app by using a Mobile Apps back end. Con la sincronizzazione offline è possibile interagire con un'app per dispositivi mobili —visualizzando, aggiungendo e modificando i dati— anche quando non è disponibile una connessione di rete.With offline sync, users can interact with a mobile app—viewing, adding, or modifying data—even when there is no network connection.