Tutoriel : Utiliser le mode d’appareil partagé dans votre application Android
Dans ce tutoriel, les développeurs Android et les administrateurs de locataires Microsoft Entra découvrent le code, l’application Authenticator et les paramètres de locataire nécessaires à l’activation du mode d’appareil partagé pour une application Android.
Dans ce tutoriel, vous allez :
- Télécharger un exemple de code
- Activer et détecter le mode d’appareil partagé
- Détecter le mode monocompte ou multicompte
- Détecter un commutateur utilisateur, et activer la connexion et la déconnexion globales
- Configurer le locataire et enregistrer l'application
- Configurer un appareil Android en mode d’appareil partagé
- Exécution de l'exemple d'application
Prérequis
- Compte Azure avec un abonnement actif. Créez un compte gratuitement.
Guide du développeur
Cette section du tutoriel fournit des conseils aux développeurs concernant l’implémentation du mode d’appareil partagé dans une application Android à l’aide de la bibliothèque d’authentification Microsoft (MSAL). 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.
Télécharger l’exemple
Clonez l’exemple d’application à partir de GitHub. L’exemple a la possibilité de fonctionner en mode monocompte ou multicompte.
Ajouter le SDK MSAL à votre dépôt 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.+'
}
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 de configuration.
Affectez à "shared_device_mode_supported" la valeur 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" la valeur "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 le mode "single account".
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 pour ê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);
}
Guide de l’administrateur
Les étapes suivantes décrivent la configuration de votre application et la mise de votre appareil en mode appareil partagé.
Enregistrement de l’application
Tout d’abord, enregistrez l’application au sein de votre locataire organisationnel. Ensuite, fournissez les valeurs ci-dessous 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.
Remarque
Quand vous inscrivez votre application, utilisez le guide de démarrage rapide situé dans la partie gauche, puis sélectionnez Android. Vous accédez alors à une page dans laquelle vous êtes invité à fournir le nom du package et le code de hachage de la signature de votre application. Ces informations sont très importantes pour garantir le fonctionnement de la configuration de votre application. Vous recevez ensuite un objet de configuration que vous pouvez utiliser pour votre application que vous allez couper et coller dans votre fichier auth_config.json.
Vous devez sélectionner Effectuer cette modification pour moi, puis fournir les valeurs demandées par le démarrage rapide. Après cela, nous générerons tous les fichiers de configuration dont vous avez besoin.
Configurer un locataire
À des fins de test, configurez ce qui suit dans votre locataire : au moins deux employés, un seul administrateur d’appareil cloud et un seul administrateur général. Définissez l'administrateur des appareils cloud en modifiant les rôles organisationnels. 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. Ajoutez les utilisateurs qui peuvent mettre un appareil en mode partagé.
Configurer un appareil Android en mode partagé
Télécharger l’application Authenticator
Téléchargez l’application Microsoft Authenticator à partir de Google Play Store. Si vous avez déjà téléchargé l’application, vérifiez qu’il s’agit de la version la plus récente.
Paramètres de l’application Authenticator et inscription de l’appareil dans le cloud
Lancez l’application Authenticator et accédez à la page du compte principal. Une fois que vous voyez la page Ajouter un compte, vous êtes prêt à rendre l’appareil partagé.
Accédez au volet Paramètres à l’aide de la barre de menus de droite. Sélectionnez Inscription d’appareil sous Comptes professionnels et scolaires.
Lorsque vous cliquez sur ce bouton, vous êtes invité à autoriser l’accès aux contacts de l’appareil. Ceci est dû à l’intégration de compte d’Android sur l’appareil. Choisissez Autoriser.
L’administrateur d’appareil cloud doit entrer son adresse e-mail professionnelle sous Ou inscrire en tant qu’appareil partagé. Cliquez ensuite sur le bouton Inscrire en tant qu’appareil partagé, puis entrez ses informations d’identification.
L’appareil est maintenant en mode partagé.
Toutes les connexions et déconnexions sur l’appareil sont globales, ce qui signifie qu’elles s’appliquent à toutes les applications intégrées à MSAL et Microsoft Authenticator sur l’appareil. Vous pouvez maintenant déployer des applications sur l’appareil qui utilise les fonctionnalités du mode d’appareil partagé.
Afficher l'appareil partagé
Une fois que vous avez passé un appareil en mode partagé, il est connu de votre organisation et suivi dans son locataire. Vous pouvez afficher vos appareils partagés en consultant le type de jointure.
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
Apprenez-en davantage sur l’utilisation de la bibliothèque d’authentification Microsoft et du mode d’appareil partagé sur les appareils Android :