Mode d’appareil partagé pour les appareils Android

Les travailleurs de première ligne tels que les associés au détail, les membres de l’équipage de vol et les travailleurs des services de terrain utilisent souvent un appareil mobile partagé pour effectuer leur travail. Ces appareils partagés peuvent présenter des risques de sécurité si vos utilisateurs partagent leurs mots de passe ou codes CONFIDENTIELs, intentionnellement ou non, pour accéder aux données client et métier sur l’appareil partagé.

Le mode d’appareil partagé vous permet de configurer un appareil Android 8.0 ou version ultérieure afin que les employés puissent partager l’appareil en toute sécurité. Les employés peuvent se connecter une seule fois et obtenir l’authentification unique (SSO) à toutes les applications qui prennent en charge cette fonctionnalité, ce qui leur donne un accès plus rapide aux informations. Lorsque les employés se déconnectent à la fin de leur temps de travail ou de leur tâche, ils sont automatiquement déconnectés de l’appareil et de toutes les applications prises en charge, rendant ainsi l’appareil prêt pour l’utilisateur suivant.

Pour tirer parti de la fonctionnalité mode appareil partagé, les développeurs d’applications et les administrateurs d’appareils cloud fonctionnent ensemble :

1. Les administrateurs d’appareils préparent l’appareil à être partagé manuellement ou à l’aide d’un fournisseur de gestion des appareils mobiles (GPM), comme Microsoft Intune. L’option privilégiée consiste à utiliser une solution MDM, car elle permet de configurer les appareils en mode appareil partagé à grande échelle via le provisionnement sans intervention. Le MDM déploie l’application Microsoft Authenticator sur les appareils et active le « mode partagé » pour chaque appareil au moyen d’une mise à jour de configuration gérée sur l’appareil. Ce paramètre en mode partagé change le comportement des applications prises en charge sur l’appareil. Cette configuration du fournisseur MDM définit le mode d’appareil partagé pour l’appareil et déclenche l’inscription d’appareils partagés à l’aide de l’application Authenticator.

2. Les développeurs d’applications écrivent une application à compte unique (les applications à plusieurs comptes ne sont pas prises en charge en mode d’appareil partagé) pour gérer le scénario suivant :

   • Connectez-vous à l’échelle de l’appareil utilisateur via n’importe quelle application prise en charge
   • Déconnecter un utilisateur sur l’ensemble de l’appareil via n’importe quelle application prise en charge
   • Interroger l’état de l’appareil pour déterminer si votre application se trouve sur un appareil en mode appareil partagé
   • Interroger l’état de l’appareil de l’utilisateur pour déterminer les modifications apportées à votre application depuis la dernière utilisation

   La prise en charge du mode appareil partagé doit être considérée comme une mise à niveau des fonctionnalités pour votre application et peut contribuer à augmenter son adoption dans les environnements où le même appareil est utilisé parmi plusieurs utilisateurs.

   Important

   Microsoft applications qui prennent en charge le mode appareil partagé sur Android ne nécessitent aucune modification et doivent simplement être installées sur l'appareil pour obtenir les avantages fournis avec le mode appareil partagé.

Configurer l’appareil en mode Appareil partagé

Pour configurer votre appareil Android pour prendre en charge le mode d’appareil partagé, il doit exécuter Android OS 8.0 ou version ultérieure. L’appareil doit également être réinitialisé aux paramètres d’usine, ou toutes les applications Microsoft et autres applications pour lesquelles le mode appareil partagé est activé doivent être désinstallées puis réinstallées.

Microsoft Intune prend en charge l’approvisionnement sans contact pour les appareils en mode d’appareil partagé Microsoft Entra, ce qui signifie que l’appareil peut être configuré et inscrit dans Intune avec une interaction minimale du travailleur de première ligne. Pour configurer un appareil en mode Appareil partagé lors de l’utilisation de Microsoft Intune en tant que MDM, consultez Configurer l’inscription des appareils en mode Appareil partagé dans Microsoft Entra.

Modifier votre application Android pour prendre en charge le mode d’appareil partagé

Vos utilisateurs dépendent de vous pour vous assurer que leurs données ne sont pas divulguées à un autre utilisateur. Les sections suivantes fournissent des signaux utiles pour indiquer à votre application qu’une modification s’est produite et qu’elle doit être gérée. Vous êtes responsable de la vérification de l’état de l’utilisateur sur l’appareil chaque fois que votre application est utilisée, puis d’effacer les données de l’utilisateur précédent. Cela inclut le cas où il est rechargé depuis l’arrière-plan en mode multitâche. Sur une modification de l’utilisateur, vous devez vous assurer que les données de l’utilisateur précédent sont effacées et que toutes les données mises en cache affichées dans votre application sont supprimées. Nous vous recommandons vivement et votre entreprise d’effectuer un processus de révision de sécurité après la mise à jour de votre application pour prendre en charge le mode d’appareil partagé.

Ajoutez le SDK Microsoft Authentication Library (MSAL) aux dépendances de votre 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:5.+'
}

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

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 le mode compte unique ou le mode à plusieurs comptes. Les applications en mode appareil partagé fonctionnent uniquement en mode monocompte.

Si vous ne prévoyez pas de prendre en charge le mode multicomptes, définissez "account_mode" sur "SINGLE" dans votre fichier de configuration MSAL. 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 le mode "single account".

Voici un exemple du fichier de configuration :

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

Pour plus d’informations sur la configuration de votre fichier de configuration, reportez-vous à la documentation de configuration .

Prise en charge à la fois d’un compte unique et de plusieurs comptes

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 caster vers l’interface appropriée quand vous obtenez votre objet PublicClientApplication. Le code suivant vérifie s'il s'agit d'un mode multicomptes ou d'un mode monocompte, et adapte 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 :

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;

PublicClientApplication.create(
    this.getApplicationCOntext(),
    R.raw.auth_config_single_account,
    new PublicClientApplication.ApplicationCreatedListener() {

        @Override
        public void onCreated(IPublicClientApplication application){
            mSingleAccountApp = (ISingleAccountPublicClientApplication)application;
        }

        @Override
        public void onError(MsalException exception){
            /*Fail to initialize PublicClientApplication */
        }
    });

Détecter le mode appareil partagé

La détection du mode d’appareil partagé est importante pour votre application. De nombreuses applications nécessitent un changement dans leur expérience utilisateur (UX) lorsque l’application est utilisée sur un appareil partagé. Par exemple, votre application peut avoir une fonctionnalité « Inscription », qui n’est pas appropriée pour un travailleur de première ligne, car elle a probablement déjà un compte. Vous pouvez également ajouter une sécurité supplémentaire à la gestion des données de votre application si elle est en mode appareil partagé.

Utilisez l’API isSharedDevice dans IPublicClientApplication pour déterminer si une application s’exécute sur un appareil en mode d’appareil partagé.

Les extraits de code suivants montrent des exemples d’utilisation de l’API isSharedDevice .

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

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

Une autre partie importante de la prise en charge du mode appareil partagé détermine l’état de l’utilisateur sur l’appareil et l’effacement des données d’application si un utilisateur a changé ou s’il n’y a pas d’utilisateur du tout sur l’appareil. Vous êtes responsable de la vérification que les données ne sont pas divulguées à un autre utilisateur.

Vous pouvez utiliser l’API getCurrentAccountAsync pour interroger le compte actuellement connecté 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;
        final AcquireTokenSilentParameters silentParameters = new AcquireTokenSilentParameters.Builder()
                        .fromAuthority(signedInUser.getAuthority())
                        .forAccount(signedInUser)
                        .withScopes(Arrays.asList(getScopes()))
                        .withCallback(getAuthSilentCallback())
                        .build();
        mSingleAccountApp.acquireTokenSilentAsync(silentParameters);
      }
    }
    @Override
    public void onAccountChanged(@Nullable IAccount priorAccount, @Nullable Iaccount currentAccount)
    {
      if (currentAccount == null)
      {
        //Perform a cleanup task as the signed-in account changed.
        cleaUp();
      }
    }
    @Override
    public void onError(@NonNull Exception exception)
    {
        //getCurrentAccountAsync failed
    }
  }
}

Connecter globalement un utilisateur

Lorsqu’un appareil est configuré en tant qu’appareil partagé, votre application peut appeler l’API signIn pour se connecter au compte. Le compte sera disponible globalement pour toutes les applications éligibles sur l’appareil une fois que la première application se connecte au compte.

final SignInParameters signInParameters = ... /* create SignInParameters object */
mSingleAccountApp.signIn(signInParameters);

Déconnecter globalement un utilisateur

Le code suivant supprime le compte connecté et efface les jetons mis en cache non seulement de l’application, mais également de l’appareil en mode appareil partagé. Toutefois, il n’efface pas les données de votre application. Vous devez effacer les données de votre application et effacer toutes les données mises en cache que votre application peut afficher à l’utilisateur.

mSingleAccountApp.signOut(new ISingleAccountPublicClientApplication.SignOutCallback() {
    @Override
    public void onSignOut() {
        // clear data from your application
    }

    @Override
    public void onError(@NonNull MsalException exception) {
        // signout failed, show error
    }
});

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.

Lorsque qu’une notification de changement de compte est reçue, récupérez immédiatement l’utilisateur connecté et vérifiez si l’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);
}

Microsoft applications qui prennent en charge le mode d’appareil partagé

Ces applications Microsoft prennent en charge Microsoft Entra mode d’appareil partagé :

• Microsoft Teams
• Microsoft Viva Engage (précédemment Yammer)
• Outlook
• Microsoft Power Apps
• Microsoft 365
• Microsoft Power BI Mobile
• Microsoft Edge
• Écran d’accueil géré

MdMs tiers qui prennent en charge le mode d’appareil partagé

Ces fournisseurs de Gestion des appareils mobiles tiers prennent en charge Microsoft Entra mode d’appareil partagé :

• VMware Workspace ONE
• SOTI MobiControl
• 42Gears SureMDM

Déconnexion de l’appareil partagé et cycle de vie global de l’application

Lorsqu’un utilisateur se déconnecte, vous devez prendre des mesures pour protéger la confidentialité et les données de l’utilisateur. Par exemple, si vous créez une application de dossiers médicaux, vous souhaitez vous assurer que, lorsque l’utilisateur se déconnecte, les dossiers des patients affichés précédemment sont effacés. Votre application doit être préparée pour la confidentialité des données et vérifier chaque fois qu’elle entre au premier plan.

Lorsque votre application utilise MSAL pour déconnecter l’utilisateur d’une application s’exécutant sur l’appareil en mode partagé, le compte connecté et les jetons mis en cache sont supprimés de l’application et de l’appareil.

Le diagramme suivant montre le cycle de vie global de l’application et les événements courants qui peuvent se produire pendant l’exécution de votre application. Le diagramme couvre le moment où un lancement d’activité, la connexion et la déconnexion d’un compte, ainsi que la façon dont les événements tels que la suspension, la reprise et l’arrêt de l’activité s’intègrent.

Étapes suivantes

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

Mode d’appareil partagé pour les appareils Android