Tutoriel : Préparer votre application mobile Android pour l’authentification native

2025-04-18

S’applique à : Cercle blanc avec un symbole X gris. Locataires de main-d’œuvre Cercle vert avec un symbole de coche blanche. Locataires externes (en savoir plus)

Ce tutoriel montre comment ajouter le Kit de développement logiciel (SDK) d’authentification native MSAL (Microsoft Authentication Library) à une application mobile Android.

Dans ce tutoriel, vous allez :

Ajoutez des dépendances MSAL.
Créez un fichier de configuration.
Créez une instance du Kit de développement logiciel (SDK) MSAL.

Conditions préalables

Si ce n’est déjà fait, suivez les instructions de Connexion des utilisateurs dans l’exemple d’application mobile Android (Kotlin) en utilisant l’authentification native et enregistrez une application dans votre locataire externe. Veillez à effectuer les étapes suivantes :
- Inscrire une application.
- Activez les flux d’authentification publics et natifs.
- Accordez des autorisations d’API.
- Créez un flux utilisateur.
- Associez l’application au flux utilisateur.
Un projet Android. Si vous n’avez pas de projet Android, créez-le.

Ajouter des dépendances MSAL

Ouvrez votre projet dans Android Studio ou créez un projet.

Ouvrez le build.gradle de votre application et ajoutez les dépendances suivantes :

allprojects {
    repositories {
        //Needed for com.microsoft.device.display:display-mask library
        maven {
            url 'https://pkgs.dev.azure.com/MicrosoftDeviceSDK/DuoSDK-Public/_packaging/Duo-SDK-Feed/maven/v1'
            name 'Duo-SDK-Feed'
        }
        mavenCentral()
        google()
    }
}
//...

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

Dans Android Studio, sélectionnez Projet>de synchronisation de fichiers avec Gradle Files.

Créer un fichier de configuration

Vous transmettez les identificateurs de locataire requis, tels que l’ID d’application (client), au SDK MSAL via un paramètre de configuration JSON.

Procédez comme suit pour créer un fichier de configuration :

Dans le volet de projet d’Android Studio, accédez à app\src\main\res.
Cliquez avec le bouton droit sur res et sélectionnez Nouveau>répertoire. Entrez raw en tant que nouveau nom de répertoire, puis sélectionnez OK.
Dans app\src\main\res\raw, créez un fichier JSON appelé auth_config_native_auth.json.

Dans le auth_config_native_auth.json fichier, ajoutez les configurations MSAL suivantes :

{ 
  "client_id": "Enter_the_Application_Id_Here", 
  "authorities": [ 
    { 
      "type": "CIAM", 
      "authority_url": "https://Enter_the_Tenant_Subdomain_Here.ciamlogin.com/Enter_the_Tenant_Subdomain_Here.onmicrosoft.com/" 
    } 
  ], 
  "challenge_types": ["oob"], 
  "logging": { 
    "pii_enabled": false, 
    "log_level": "INFO", 
    "logcat_enabled": true 
  } 
} 
 //...

Remplacez les espaces réservés suivants par les valeurs de votre locataire que vous avez obtenues à partir du centre d’administration Microsoft Entra :
- Remplacez l’espace Enter_the_Application_Id_Here réservé par l’ID d’application (client) de l’application que vous avez inscrite précédemment.
- Remplacez Enter_the_Tenant_Subdomain_Here par le sous-domaine de l’annuaire (tenant). Par exemple, si le domaine principal de votre locataire est contoso.onmicrosoft.com, utilisez contoso. Si vous ne disposez pas du nom de votre locataire, découvrez de quelle manière consulter les détails de votre locataire.
Les types de défis sont une liste de valeurs que l’application utilise pour informer Microsoft Entra de la méthode d’authentification qu’elle prend en charge.
- Pour les flux d’inscription et de connexion avec un code secret à usage unique par e-mail, utilisez ["oob"].
- Pour les flux d’inscription et de connexion avec e-mail et mot de passe, utilisez ["oob","password"].
- Pour la réinitialisation de mot de passe en libre-service (SSPR), utilisez ["oob"].
En savoir plus sur les types de défis.

Facultatif : Configuration de la journalisation

Activez la journalisation lors de la création de l’application en créant un rappel de journalisation, afin que le SDK puisse générer des journaux d’activité.

import com.microsoft.identity.client.Logger

fun initialize(context: Context) {
        Logger.getInstance().setExternalLogger { tag, logLevel, message, containsPII ->
            Logs.append("$tag $logLevel $message")
        }
    }

Pour configurer l’enregistreur d’événements, vous devez ajouter une section dans le fichier de configuration : auth_config_native_auth.json

    //...
   { 
     "logging": { 
       "pii_enabled": false, 
       "log_level": "INFO", 
       "logcat_enabled": true 
     } 
   } 
    //...

logcat_enabled : active la fonctionnalité de journalisation de la bibliothèque.
pii_enabled : spécifie si les messages contenant des données personnelles ou des données organisationnelles sont enregistrés. Quand la valeur est false, les journaux ne contiennent pas de données personnelles. Quand la valeur est true, les journaux peuvent contenir des données personnelles.
log_level : utilisez-la pour déterminer le niveau de journalisation à activer. Android prend en charge les niveaux de journal suivants :
1. ERREUR
2. Avertissement
3. INFORMATIONS
4. DÉTAILLÉ

Pour plus d’informations sur la journalisation MSAL, consultez Journalisation dans MSAL pour Android.

Créer une instance msAL SDK d’authentification native

Dans la onCreate() méthode, créez une instance MSAL afin que l’application puisse effectuer l’authentification avec votre locataire via l’authentification native. La createNativeAuthPublicClientApplication() méthode retourne une instance appelée authClient. Transmettez le fichier de configuration JSON que vous avez créé précédemment en tant que paramètre.

    //...
    authClient = PublicClientApplication.createNativeAuthPublicClientApplication( 
        this, 
        R.raw.auth_config_native_auth 
    )
    //...

Votre code doit ressembler à l’extrait de code suivant :

    class MainActivity : AppCompatActivity() { 
        private lateinit var authClient: INativeAuthPublicClientApplication 
 
        override fun onCreate(savedInstanceState: Bundle?) { 
            super.onCreate(savedInstanceState) 
            setContentView(R.layout.activity_main) 
 
            authClient = PublicClientApplication.createNativeAuthPublicClientApplication( 
                this, 
                R.raw.auth_config_native_auth 
            ) 
            getAccountState() 
        } 
 
        private fun getAccountState() {
            CoroutineScope(Dispatchers.Main).launch {
                val accountResult = authClient.getCurrentAccount()
                when (accountResult) {
                    is GetAccountResult.AccountFound -> {
                        displaySignedInState(accountResult.resultValue)
                    }
                    is GetAccountResult.NoAccountFound -> {
                        displaySignedOutState()
                    }
                }
            }
        } 
 
        private fun displaySignedInState(accountResult: AccountState) { 
            val accountName = accountResult.getAccount().username 
            val textView: TextView = findViewById(R.id.accountText) 
            textView.text = "Cached account found: $accountName" 
        } 
 
        private fun displaySignedOutState() { 
            val textView: TextView = findViewById(R.id.accountText) 
            textView.text = "No cached account found" 
        } 
    }

Récupérez le compte mis en cache à l’aide de l’objet getCurrentAccount(), qui retourne un objet. accountResult
Si un compte est trouvé dans la persistance, utilisez GetAccountResult.AccountFound pour afficher l'état connecté.
Sinon, utilisez GetAccountResult.NoAccountFound pour afficher un état déconnecté.

Veillez à inclure les instructions d'importation. Android Studio doit automatiquement inclure les déclarations d'importation pour vous.

Étape suivante

Tutoriel : Ajouter l’inscription dans une application mobile Android à l’aide de l’authentification native

Partager via