Partager via

Mode d’appareil partagé pour les appareils Android

  • Article

Les employés de terrain, comme les représentants, les membres d’équipage et les techniciens d’intervention, 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 leur mot de passe ou leurs codes secrets, intentionnellement ou non, pour accéder aux données client et métier sur l’appareil partagé.

Le mode Appareil partagé vous permet de configurer un appareil Android version 8.0 ou ultérieure pour qu’il soit partagé en toute sécurité par les employés. Les employés peuvent se connecter une seule fois et obtenir l’authentification unique (SSO) pour toutes les applications qui prennent en charge cette fonctionnalité, ce qui leur permet d’accéder plus rapidement 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é en mode Appareil partagé, les développeurs d’applications et les administrateurs d’appareils cloud travaillent ensemble :

  1. Les administrateurs d’appareils préparent l’appareil pour qu’il soit partagé manuellement à l’aide d’un fournisseur de gestion des appareils mobiles (GAM) tel que Microsoft Intune. L’option préférée utilise une fonctionnalité de gestion des appareils mobiles, car elle permet la configuration de l’appareil en mode Appareil partagé à grande échelle via l’approvisionnement sans intervention. La fonction GAM envoie (push) l’application Microsoft Authenticator sur les appareils et active le « mode partagé » pour chaque appareil via une mise à jour de configuration gérée sur l’appareil. Ce paramètre Mode partagé est ce qui modifie le comportement des applications prises en charge sur l’appareil. Cette configuration du fournisseur GAM définit le mode 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 monocompte (les applications multicomptes ne sont pas prises en charge en mode Appareil partagé) pour gérer le scénario suivant :

    • Connexion d’un utilisateur au niveau de l’appareil via n’importe quelle application prise en charge
    • Déconnexion d’un utilisateur au niveau de l’appareil via n’importe quelle application prise en charge
    • Requête de l’état de l’appareil pour déterminer si votre application se trouve sur un appareil qui est en mode d’appareil partagé
    • Requête de l’état de l’appareil de l’utilisateur sur l’appareil pour déterminer si quelque chose a changé depuis la dernière utilisation de votre application

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

    Important

    Les applications Microsoft 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 bénéficier des avantages fournis avec le mode d’appareil partagé.

Configurer l’appareil en mode Appareil partagé

Pour configurer votre appareil Android de sorte à prendre en charge le mode Appareil partagé, vous devez exécuter Android 8.0 ou une version ultérieure. L’appareil doit également être réinitialisé aux paramètres d’usine et toutes les applications Microsoft et en mode Appareil partagé doivent être désinstallées et réinstallées.

Microsoft Intune prend en charge l’approvisionnement sans contact pour les appareils en mode d’appareil partagé Microsoft Entra. Cela signifie que les appareils peuvent être configurés et inscrits dans Intune avec une interaction minimale de la part des personnes travaillant en première ligne. Pour configurer l’appareil en mode d’appareil partagé lors de l’utilisation de Microsoft Intune comme GPM, consultez Configurer l’inscription des appareils en mode d’appareil partagé Microsoft Entra.

Modifier votre application Android pour prendre en charge le mode Appareil partagé

Vos utilisateurs dépendent de vous et vous devez leur garantir que leurs données ne seront pas divulguées à un autre utilisateur. Les sections suivantes fournissent des signaux utiles pour indiquer à votre application qu’une modification a eu lieu et doit être traitée. Il vous incombe de vérifier 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 rechargement en arrière-plan en mode multitâche. En cas de changement d’utilisateur, vous devez vous assurer que les données de l’utilisateur précédent sont effacées et que toutes les données en cache affichées dans votre application sont supprimées. Nous vous recommandons vivement, à vous et à votre entreprise, de procéder à un examen de sécurité après avoir mis à jour votre application pour qu’elle prenne en charge le mode Appareil partagé.

Ajouter le Kit de développement logiciel (SDK) de bibliothèque d’authentification Microsoft (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 Mode monocompte ou mode multicompte. Les applications en mode d’appareil partagé fonctionnent uniquement en mode monocompte.

Si vous ne prévoyez pas de prendre en charge le mode à plusieurs comptes, définissez "account_mode" sur "SINGLE" dans votre fichier config 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 de 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"
      }
    }
  ]
}

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

Prise en charge à la fois d’un seul compte 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é :

modèle d’héritage d’application cliente publique

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 :

Appareil en mode partagé Appareil personnel
Comptes Un seul compte Plusieurs comptes
Connexion Global Global
Déconnexion Global Chaque application peut contrôler si la déconnexion est locale sur l’application.
Types de comptes pris en charge Comptes professionnels uniquement Comptes personnels et professionnels pris en charge

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 d’appareil partagé

La détection du mode Appareil partagé est importante pour votre application. De nombreuses applications nécessitent une modification de leur expérience utilisateur (UX) quand l’application est utilisée sur un appareil partagé. Par exemple, votre application peut avoir une fonctionnalité « Inscription », ce qui n’est pas approprié pour un employé de terrain, car il a probablement déjà un compte. Vous pouvez également ajouter une sécurité supplémentaire au traitement des données de votre application si celle-ci est en mode Appareil partagé.

Utilisez l’API isSharedDevice dans IPublicClientApplication pour déterminer si une application est en cours d’exécution sur un appareil en mode Appareil partagé.

Les extraits de code suivants présentent des exemples d’utilisation de isSharedDevice l’API.

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

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

Une autre partie importante de la prise en charge du mode Appareil partagé consiste à déterminer l’état de l’utilisateur sur l’appareil et à effacer les données d’application si l’utilisateur de l’appareil a changé ou si aucun utilisateur n’est enregistré sur l’appareil. Il vous incombe de veiller à ce que les données ne soient 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

Quand 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 dans le monde entier pour toutes les applications admissibles sur l’appareil après la première connexion de l’application sur le 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 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 toutes les données 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.

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

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

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

MDM tiers qui prennent en charge le mode appareil partagé

Ces fournisseurs tiers de gestion des appareils mobiles (GAM) prennent en charge le mode de périphérique partagé Microsoft Entra :

Déconnexion des appareils partagés et cycle de vie global des applications

Quand un utilisateur se déconnecte, vous devez prendre des mesures pour protéger sa confidentialité et ses données. Par exemple, si vous créez une application de dossiers médicaux, vous devez garantir la suppression des dossiers des patients précédemment affichés quand l’utilisateur se déconnecte. Votre application doit être préparée à la protection des données personnelles et procéder à une vérification chaque fois qu’elle passe au premier plan.

Quand votre application utilise MSAL pour déconnecter l’utilisateur dans une application en cours d’exécution sur un 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 présente le cycle de vie global des applications et les événements courants qui peuvent se produire pendant que votre application s’exécute. Le diagramme présente les étapes effectuées à compter du lancement d’une activité, la connexion et la déconnexion d’un compte, ainsi que la façon dont des événements tels que la suspension, la reprise et l’arrêt de l’activité s’intègrent.

Cycle de vie des applications d’appareils partagés

É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