Partager via

Ajout de l’authentification à votre application Android

  • Article

Résumé

Dans ce didacticiel, vous allez ajouter l’authentification au projet de démarrage rapide todolist sur Android en faisant appel à un fournisseur d’identité pris en charge. Ce didacticiel est basé sur le didacticiel Prise en main de Mobile Apps , que vous devez effectuer en premier.

Inscription de votre application pour l’authentification et configuration d’Azure App Service

Commencez par inscrire votre application auprès d’un site de fournisseur d’identité, puis définissez les informations d’identification générées par le fournisseur dans le serveur principal Mobile Apps.

  1. Configurez votre fournisseur d’identité en suivant les instructions correspondantes :

  2. Répétez les étapes précédentes pour chaque fournisseur que vous souhaitez prendre en charge dans votre application.

Ajouter votre application aux URL de redirection externes autorisées

L’authentification sécurisée nécessite de définir un nouveau schéma d’URL pour votre application. Cela permet au système d’authentification de vous rediriger vers votre application une fois le processus d’authentification terminé. Dans ce didacticiel, nous utilisons le schéma d’URL appname. Toutefois, vous pouvez utiliser le schéma d’URL de votre choix. Il doit être propre à votre application mobile. Pour activer la redirection côté serveur, procédez comme suit :

  1. Dans le portail Azure, sélectionnez votre instance App Service.

  2. Cliquez sur l’option de menu Authentication/Authorisation.

  3. Dans URL de redirection externes autorisées, saisissez appname://easyauth.callback. La chaîne appname de cette chaîne est le schéma d’URL de votre application mobile. Elle doit être conforme à la spécification d’URL normale pour un protocole (utiliser des lettres et des chiffres uniquement et commencer par une lettre). Vous devez noter la chaîne que vous choisissez, dans la mesure où vous devez ajuster votre code d’application mobile avec le schéma d’URL à plusieurs endroits.

  4. Cliquez sur OK.

  5. Cliquez sur Enregistrer.

Restriction des autorisations pour les utilisateurs authentifiés

Par défaut, les API d’un serveur principal Mobile Apps peuvent être appelées de manière anonyme. Vous devez ensuite restreindre l’accès aux clients authentifiés uniquement.

  • Serveur principal Node.js (par le biais du Portail Azure) :

    Dans vos paramètres de Mobile Apps, cliquez sur tables faciles , puis sélectionnez votre table. Cliquez sur Modifier les autorisations, sélectionnez Accès authentifié uniquement pour toutes les autorisations, puis cliquez sur Enregistrer.

  • Serveur principal .NET (C#) :

    Dans le projet serveur, accédez à contrôleurs>TodoItemController. cs. Ajoutez l’attribut [Authorize] à la classe TodoItemController comme suit : Pour restreindre l’accès à des méthodes spécifiques, vous pouvez également appliquer cet attribut à ces méthodes uniquement au lieu de la classe. Publier à nouveau le projet de serveur

      [Authorize]
  public class TodoItemController : TableController<TodoItem>

  • Serveur principal Node.js (via le code Node.js) :

    Pour demander l’authentification pour l’accès des tables, ajoutez la ligne suivante au script de serveur Node.js :

      table.access = 'authenticated';

    Pour plus d’informations, consultez la section Procédure : exiger une authentification pour l’accès aux tables. Pour savoir comment télécharger le projet de code de démarrage rapide de votre site, consultez Procédure : télécharger le projet de code de démarrage rapide du serveur principal Node.js à l’aide de Git.

  • Dans Android Studio, ouvrez le projet que vous avez terminé avec le didacticiel Prise en main de Mobile Apps. Dans le menu Exécuter, cliquez sur Exécuter l’application et vérifiez qu’une exception non prise en charge avec le code d’état 401 (Non autorisé) est générée après le démarrage de l’application.

    Cela se produit car l’application essaie d’accéder au serveur principal en tant qu’utilisateur non authentifié, mais la table TodoItem requiert désormais l’authentification.

Ensuite, mettez à jour l’application pour authentifier les utilisateurs avant de demander des ressources à partir du serveur principal Mobile Apps.

Ajout de l'authentification à l'application

  1. Ouvrez le projet dans Android Studio.

  2. Dans l’Explorateur de projets d’Android Studio, ouvrez le fichier ToDoActivity.java, puis ajoutez les instructions d’importation suivantes :

    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. Ajoutez la méthode suivante à la classe fichier 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");
            }
        }
    }
}

    Ce code crée une méthode pour gérer le processus d’authentification Google. Une boîte de dialogue affiche l’identificateur de l’utilisateur authentifié. Vous pouvez agir uniquement si l’authentification a réussi.

    Notes

    Si vous utilisez un autre fournisseur d’identité que Google, remplacez la valeur transférée à la méthode login par l’une des valeurs suivantes : MicrosoftAccount, Facebook, Twitter ou windowsazureactivedirectory.

  4. Dans la méthode onCreate, ajoutez la ligne de code suivante après le code qui permet d’instancier l’objet MobileServiceClient.

    authenticate();

    Cet appel lance le processus d'authentification.

  5. Déplacez le code restant après authenticate(); dans la méthode OnCreate vers une nouvelle méthode 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();
}

  6. Pour garantir la redirection souhaitée, ajoutez l’extrait de code suivant de RedirectUrlActivity à 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. Ajoutez redirectUriScheme à build.gradle de votre application Android.

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

  8. Ajoutez com.android.support:customtabs:23.0.1 aux dépendances dans votre build.gradle :

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

  9. Dans le menu Exécuter, cliquez sur Exécuter l’application pour démarrer l’application, puis connectez-vous avec le fournisseur d’identité choisi.

Avertissement

Le schéma d’URL mentionné respecte la casse. Assurez-vous que toutes les occurrences de {url_scheme_of_you_app} utilisent la même casse.

Une fois que vous êtes connecté, l’application doit s’exécuter sans erreur et vous devez être en mesure d’interroger le service principal et de mettre à jour les données.

Mise en cache de jetons d'authentification sur le client

L’exemple précédent présentait une connexion standard, qui nécessite que le client contacte le fournisseur d’identité et le service principal Azure à chaque démarrage de l’application. Cette méthode est inefficace et risque de vous poser des problèmes d’utilisation si de nombreux clients tentent de démarrer votre application simultanément. Une meilleure approche consiste à mettre en cache le jeton d’autorisation renvoyé par le service Azure et à tenter de l’utiliser avant de recourir à une connexion basée sur un fournisseur.

Notes

Vous pouvez mettre en cache le jeton émis par le service principal Azure, que vous utilisiez l’authentification gérée par le client ou gérée par le service. Ce didacticiel utilise cette dernière.

  1. Ouvrez le fichier ToDoActivity.java, puis ajoutez les instructions import suivantes :

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

  2. Ajoutez les membres suivants à la classe ToDoActivity :

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

  3. Dans le fichier ToDoActivity.java, ajoutez la définition ci-après pour la méthode 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();
}

    Cette méthode stocke l’identificateur d’utilisateur et le jeton dans un fichier de préférences marqué comme privé. Cette opération doit protéger l’accès au cache afin que les autres applications de l’appareil n’aient pas accès au jeton. La préférence est exécutée dans le bac à sable (sandbox) de l’application. Toutefois, si une personne tente d'accéder à l'appareil, il est possible qu'elle puisse accéder au cache du jeton par d'autres moyens.

    Notes

    Vous pouvez protéger davantage le jeton avec un chiffrement si l’accès du jeton à vos données est considéré comme très sensible et que quelqu’un peut accéder à l’appareil. Une solution complètement sécurisée sort du cadre de ce didacticiel et dépend de vos besoins en matière de sécurité.

  4. Dans le fichier ToDoActivity.java, ajoutez la définition ci-après pour la méthode 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;
}

  5. Dans le fichier ToDoActivity.java, remplacez les méthodes authenticate et onActivityResult par les méthodes suivantes qui utilisent un cache de jetons. Modifiez le fournisseur de connexion si vous voulez utiliser un compte autre que 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. Générez l'application et testez l'authentification à l'aide d'un compte valide. Exécutez ceci au moins deux fois. À la première exécution, vous devez recevoir une invite vous indiquant de vous connecter et de créer le cache de jetons. Après cela, chaque exécution tente de charger le cache de jetons pour l’authentification. Vous ne devriez plus être invité à vous connecter.

Étapes suivantes

Maintenant que vous avez terminé ce didacticiel sur l'authentification de base, vous pouvez passer à l'un des didacticiels suivants :