Tutoriel : ajouter la prise en charge du mode Appareil partagé à votre application Android

Dans ce tutoriel, les développeurs Android apprennent à ajouter la prise en charge du mode Appareil partagé dans une application Android à l’aide de la bibliothèque d’authentification Microsoft (MSAL) pour Android.

Dans ce tutoriel, vous allez :

Créer ou modifier une application Android existante

Pour suivre le reste du tutoriel, vous devez créer une application Android ou en modifier une existante. Si ce n’est pas déjà fait, consultez le tutoriel MSAL Android pour voir comment intégrer MSAL à votre application Android, connecter un utilisateur, appeler Microsoft Graph et déconnecter un utilisateur. Si vous préférez utiliser un exemple de code complet pour l’apprentissage et le test, téléchargez l’exemple d’application à partir de GitHub. L’exemple a la capacité de fonctionner en mode monocompte ou multicompte.

Ajouter le SDK MSAL à votre référentiel Maven local

Si vous n’utilisez pas l’exemple d’application, ajoutez la bibliothèque MSAL en tant que dépendance dans votre fichier build.gradle, comme suit :

dependencies{
  implementation 'com.microsoft.identity.client.msal:4.9.+'
}

Ajouter la prise en charge du mode Compte unique

Les applications écrites à l’aide du SDK de la bibliothèque d’authentification Microsoft (MSAL) peuvent gérer un seul compte ou plusieurs comptes. Pour plus d’informations, consultez Mode monocompte ou mode multicompte.

Les fonctionnalités de la plateforme d’identités Microsoft disponibles pour votre application varient selon que l’application s’exécute en mode monocompte ou en mode multicompte.

Les applications en mode d’appareil partagé fonctionnent uniquement en mode monocompte.

Votre application peut être conçue pour prendre en charge l’exécution à la fois sur des appareils personnels et sur des appareils partagés. Si votre application prend actuellement en charge plusieurs comptes et que vous souhaitez prendre en charge le mode d’appareil partagé, ajoutez la prise en charge du mode monocompte.

Vous pouvez également souhaiter que votre application change de comportement en fonction du type d’appareil sur lequel elle s’exécute. Utilisez ISingleAccountPublicClientApplication.isSharedDevice() pour déterminer quand elle doit exécuter en mode monocompte.

Il existe deux interfaces différentes qui représentent le type d’appareil sur lequel se trouve votre application. Lorsque vous demandez une instance d'application à partir de la fabrique d'applications de MSAL, l'objet d'application approprié est automatiquement fourni.

Le modèle d’objet suivant illustre le type d’objet que vous pouvez recevoir et ce qu’il signifie dans le contexte d’un appareil partagé :

Vous devez effectuer une vérification de type et effectuer un forçage de type cast vers l’interface appropriée quand vous obtenez votre PublicClientApplication objet. Le code suivant vérifie si des modes sont multicomptes ou monocomptes, et caster en conséquence l’objet d’application :

private IPublicClientApplication mApplication;

        // Running in personal-device mode?
        if (mApplication instanceOf IMultipleAccountPublicClientApplication) {
          IMultipleAccountPublicClientApplication multipleAccountApplication = (IMultipleAccountPublicClientApplication) mApplication;
          ...
        // Running in shared-device mode?
        } else if (mApplication instanceOf ISingleAccountPublicClientApplication) {
           ISingleAccountPublicClientApplication singleAccountApplication = (ISingleAccountPublicClientApplication) mApplication;
            ...
        }

Les différences suivantes s’appliquent selon que votre application s’exécute sur un appareil partagé ou sur un appareil personnel :

Configurer votre application pour utiliser le mode d’appareil partagé

Reportez-vous à la documentation de configuration pour plus d’informations sur la configuration de votre fichier config.

Affectez "shared_device_mode_supported" sur true dans votre fichier de configuration MSAL.

Vous n’envisagez peut-être pas de prendre en charge le mode multicompte. Cela peut être le cas si vous n’utilisez pas un appareil partagé et si l’utilisateur peut se connecter à l’application avec plusieurs comptes en même temps. Dans ce cas, affectez "account_mode" à "SINGLE". Cette valeur garantit que votre application obtient toujours ISingleAccountPublicClientApplication, ce qui simplifie considérablement l’intégration de MSAL. La valeur par défaut de "account_mode" est "MULTIPLE". Il est donc important de modifier cette valeur dans le fichier de configuration si vous utilisez "single account" le mode.

Voici un exemple de fichier auth_config.json inclus dans le répertoire app>main>res>raw de l’exemple d’application :

{
  "client_id": "Client ID after app registration at https://aka.ms/MobileAppReg",
  "authorization_user_agent": "DEFAULT",
  "redirect_uri": "Redirect URI after app registration at https://aka.ms/MobileAppReg",
  "account_mode": "SINGLE",
  "broker_redirect_uri_registered": true,
  "shared_device_mode_supported": true,
  "authorities": [
    {
      "type": "AAD",
      "audience": {
        "type": "AzureADandPersonalMicrosoftAccount",
        "tenant_id": "common"
      }
    }
  ]
}

Détecter le mode d’appareil partagé

Le mode d’appareil partagé vous permet de configurer des appareils Android de sorte qu’ils soient partagés par plusieurs employés, tout en gérant ces appareils avec des identités Microsoft. Les employés peuvent se connecter à leurs appareils et accéder rapidement aux informations sur les clients. Quand leur journée ou leur tâche est terminée, ils peuvent se déconnecter de toutes les applications sur l’appareil partagé en un seul clic et l’appareil est immédiatement prêt à être utilisé par l’employé suivant.

Utilisez isSharedDevice() pour déterminer si une application est en cours d’exécution sur un appareil qui est en mode d’appareil partagé. Votre application peut utiliser cet indicateur pour déterminer si elle doit modifier l’expérience utilisateur en conséquence.

Voici un extrait de code qui montre comment utiliser isSharedDevice(). Il provient de la classe SingleAccountModeFragment dans l’exemple d’application :

deviceModeTextView.setText(mSingleAccountApp.isSharedDevice() ? "Shared" : "Non-Shared");

Initialiser l’objet PublicClientApplication

Si vous définissez "account_mode":"SINGLE" dans le fichier de configuration MSAL, vous pouvez caster en toute sécurité l’objet d’application retourné en ISingleAccountPublicCLientApplication.

private ISingleAccountPublicClientApplication mSingleAccountApp;

/*Configure your sample app and save state for this activity*/
PublicClientApplication.create(this.getApplicationCOntext(),
  R.raw.auth_config,
  new PublicClientApplication.ApplicationCreatedListener(){
  @Override
  public void onCreated(IPublicClientApplication application){
  mSingleAccountApp = (ISingleAccountPublicClientApplication)application;
  loadAccount();
  }
  @Override
  public void onError(MsalException exception){
  /*Fail to initialize PublicClientApplication */
  }
});

Détecter le mode monocompte ou multicompte

Si vous écrivez une application destinée à être uniquement utilisée par des travailleurs de première ligne sur un appareil partagé, nous vous recommandons de prendre en charge uniquement le mode monocompte. Il inclut la plupart des applications concentrées sur les tâches, comme les applications de dossiers médicaux, les applications de facturation et la plupart des applications métier. Votre travail de développement s’en trouvera simplifié, car de nombreuses fonctionnalités du SDK n’auront pas besoin d’être adaptées.

Si votre application prend en charge plusieurs comptes et le mode d’appareil partagé, vous devez effectuer une vérification de type et caster dans l’interface appropriée comme indiqué ci-dessous.

private IPublicClientApplication mApplication;

        if (mApplication instanceOf IMultipleAccountPublicClientApplication) {
          IMultipleAccountPublicClientApplication multipleAccountApplication = (IMultipleAccountPublicClientApplication) mApplication;
          ...
        } else if (mApplication instanceOf    ISingleAccountPublicClientApplication) {
           ISingleAccountPublicClientApplication singleAccountApplication = (ISingleAccountPublicClientApplication) mApplication;
            ...
        }

Obtenir l’utilisateur connecté et déterminer si un utilisateur a changé sur l’appareil

La méthode loadAccount récupère le compte de l’utilisateur connecté. La méthode onAccountChanged détermine si l’utilisateur connecté a changé et, le cas échéant, procède à un nettoyage :

private void loadAccount()
{
  mSingleAccountApp.getCurrentAccountAsync(new ISingleAccountPublicClientApplication.CurrentAccountCallback())
  {
    @Override
    public void onAccountLoaded(@Nullable IAccount activeAccount)
    {
      if (activeAccount != null)
      {
        signedInUser = activeAccount;
        mSingleAccountApp.acquireTokenSilentAsync(SCOPES,"http://login.microsoftonline.com/common",getAuthSilentCallback());
      }
    }
    @Override
    public void onAccountChanged(@Nullable IAccount priorAccount, @Nullable Iaccount currentAccount)
    {
      if (currentAccount == null)
      {
        //Perform a cleanup task as the signed-in account changed.
        updateSingedOutUI();
      }
    }
    @Override
    public void onError(@NonNull Exception exception)
    {
    }
  }
}

Connecter globalement un utilisateur

Le code suivant connecte un utilisateur sur l’appareil à d’autres applications qui utilisent MSAL avec l’application Authenticator :

private void onSignInClicked()
{
  mSingleAccountApp.signIn(getActivity(), SCOPES, null, getAuthInteractiveCallback());
}

Déconnecter globalement un utilisateur

L’exemple suivant supprime le compte connecté et efface les jetons mis en cache de l’application, mais également de l’appareil en mode d’appareil partagé :

private void onSignOutClicked()
{
  mSingleAccountApp.signOut(new ISingleAccountPublicClientApplication.SignOutCallback()
  {
    @Override
    public void onSignOut()
    {
      updateSignedOutUI();
    }
    @Override
    public void onError(@NonNull MsalException exception)
    {
      /*failed to remove account with an exception*/
    }
  });
}

Recevoir une diffusion pour détecter la déconnexion globale lancée à partir d’autres applications

Pour recevoir la diffusion de modification de compte, vous devez inscrire un récepteur de diffusion. Il est recommandé d’inscrire votre récepteur de diffusion via les récepteurs inscrits dans le contexte.

Lorsqu’une diffusion de modification de compte est reçue, obtenez immédiatement l’utilisateur connecté et déterminez si un utilisateur a changé sur l’appareil. Si une modification est détectée, lancez le nettoyage des données pour le compte précédemment connecté. Il est recommandé d’arrêter correctement toutes les opérations et d’effectuer un nettoyage des données.

L’extrait de code suivant montre comment inscrire un récepteur de diffusion.

private static final String CURRENT_ACCOUNT_CHANGED_BROADCAST_IDENTIFIER = "com.microsoft.identity.client.sharedmode.CURRENT_ACCOUNT_CHANGED";
private BroadcastReceiver mAccountChangedBroadcastReceiver;
private void registerAccountChangeBroadcastReceiver(){
    mAccountChangedBroadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            //INVOKE YOUR PRIOR ACCOUNT CLEAN UP LOGIC HERE
        }
    };
    IntentFilter filter = new

    IntentFilter(CURRENT_ACCOUNT_CHANGED_BROADCAST_IDENTIFIER);
    this.registerReceiver(mAccountChangedBroadcastReceiver, filter);
}

Enregistrer l’application et configurer votre locataire pour le test

Avant de pouvoir configurer votre application et placer votre appareil en mode Appareil partagé, vous devez inscrire l’application au sein de votre locataire d’organisation. Ensuite, fournissez ces valeurs dans auth_config.json afin que votre application s’exécute correctement.

Pour plus d’informations sur la procédure à suivre, reportez-vous à Inscrire votre application.

Vous devez sélectionner Effectuer cette modification pour moi, puis fournir les valeurs demandées par le démarrage rapide. Lorsque vous avez terminé, Microsoft Entra ID génère tous les fichiers de configuration dont vous avez besoin.

À des fins de test, configurez ce qui suit dans votre locataire - au moins deux employés et un seul administrateur d’appareil cloud. Définissez l’administrateur d’appareil cloud en modifiant les rôles organisationnels. Dans le Centre d’administration Microsoft Entra, accédez à vos rôles organisationnels en sélectionnant Identité>Rôles et administrateurs>Rôles et administrateurs>Tous les rôles, puis sélectionnez Administrateur d’appareil cloud. Ajouter les utilisateurs qui peuvent mettre un appareil en mode partagé.

Exécution de l’exemple d’application

L’exemple d’application est une application simple qui appelle l’API Graph de votre organisation. À la première exécution, vous êtes invité à donner votre consentement, car l’application est nouvelle pour votre compte d’employé.

Étapes suivantes

Configurez un appareil Android pour exécuter des applications en mode Appareil partagé et testez votre application.