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

Article
05/30/2024

Ce tutoriel montre comment ajouter le kit SDK d’authentification native MSAL (bibliothèque d’authentification Microsoft) à une application mobile Android.

Dans ce tutoriel, vous allez apprendre à :

Ajoutez des dépendances MSAL.
Créez un fichier de configuration.
Créez une instance du kit SDK MSAL.

Prérequis

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

Ajoutez 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:5.+'
    //...
}

Dans Android Studio, sélectionnez Fichier>Synchroniser le projet avec les fichiers Gradle.

Créer un fichier de configuration

Vous passez les identificateurs de tenant (locataire) nécessaires, par exemple l’ID d’application (client), au kit SDK MSAL via un paramètre de configuration JSON.

Suivez ces étapes pour créer un fichier config :

Dans le volet de projet d’Android Studio, accédez à app\src\main\res.
Cliquez avec le bouton droit sur res, puis 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 fichier auth_config_native_auth.json, 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 tenant que vous avez obtenues à partir du centre d’administration Microsoft Entra :
- Remplacez l’espace réservé Enter_the_Application_Id_Here par l’ID d’application (client) de l’application que vous avez inscrite.
- Remplacez Enter_the_Tenant_Subdomain_Here par le sous-domaine de l’annuaire (tenant). Par exemple, si votre domaine principal du locataire est contoso.onmicrosoft.com, utilisez contoso. Si vous ne disposez pas du nom de votre locataire, découvrez comment consulter les détails de votre locataire.
Les types de demandes sont une liste de valeurs, que l’application utilise pour notifier à Microsoft Entra la méthode d’authentification prise en charge.
- Pour une inscription et une connexion du flux avec un code secret à usage unique envoyé par e-mail, utilisez ["oob"].
- Pour une inscription et une connexion du flux avec un e-mail et un mot de passe, utilisez ["oob","password"].
- Pour une réinitialisation de mot de passe en libre-service (SSPR), utilisez ["oob"].
Découvrez plus en détail les types de demandes.

Facultatif : Configurer la journalisation

Activez la journalisation au moment de la création de l’application en créant un rappel de journalisation pour que le kit SDK puisse générer les journaux.

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 config, 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 : indique si les messages contenant des données personnelles ou organisationnelles sont journalisés. Quand la valeur est false, les journaux ne contiennent pas de données personnelles. Lorsque la valeur est true, les journaux peuvent contenir des données personnelles.
log_level : vous permet de décider du niveau de journalisation à activer. Android prend en charge les niveaux de journalisation suivants :
1. ERROR
2. WARNING
3. INFO
4. DÉTAILLÉ

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

Créer une instance du kit SDK MSAL d’authentification native

Dans la méthode onCreate(), créez une instance de MSAL pour que l’application puisse effectuer l’authentification auprès de votre tenant via l’authentification native. La méthode createNativeAuthPublicClientApplication() retourne une instance appelée authClient. Passez le fichier config JSON que vous avez créé 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(accountState: 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 getCurrentAccount(), qui retourne un objet accountResult.
Si un compte est trouvé dans la persistance, utilisez GetAccountResult.AccountFound pour afficher l’état de connexion.
Sinon, utilisez GetAccountResult.NoAccountFound pour afficher l’état de déconnexion.

Veillez à inclure les instructions import. Android Studio doit inclure automatiquement les instructions import.

Étape suivante

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

Partager via