Esercitazione: Preparare l'app per dispositivi mobili Android per l'autenticazione nativa

Articolo
07/02/2024

Questa esercitazione mostra come aggiungere l’SDK per l’autenticazione nativa di Microsoft Authentication Library (MSAL) a un'app per dispositivi mobili Android.

In questa esercitazione apprenderai a:

Aggiungere dipendenze MSAL.
Creare un file di configurazione
Creare un'istanza dell’SDK MSAL.

Prerequisiti

Se non ancora fatto, seguire le istruzioni in Accesso utenti all'app per dispositivi mobili Android (Kotlin) di esempio usando l'autenticazione nativa e registrare un'app nel tenant esterno. Assicurarsi di completare i passaggi seguenti:
- Registrare un'applicazione.
- Abilitare i flussi del client pubblico e dell’autenticazione nativa.
- Concedere le autorizzazioni di accesso alle API.
- Creare un flusso utente.
- Associare l'app al flusso utente.
Progetto Android Creare un progetto Android, se non ancora fatto.

Aggiungere dipendenze MSAL

Aprire il progetto in Android Studio o creare un nuovo progetto.

Aprire il build.gradle dell'applicazione e aggiungere le dipendenze seguenti:

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

In Android Studio selezionare File>Sincronizza progetto con Gradle Files.

Creare un file di configurazione

È possibile passare gli identificatori del tenant necessari, ad esempio l'ID applicazione (client), all'SDK MSAL impostando una configurazione JSON.

Usare questi passaggi per creare un file di configurazione:

Nel riquadro dei progetti di Android Studio passare a app\src\main\res.
Fare clic con il pulsante destro del mouse su res e selezionare Nuovo>Directory. Immettere raw come nome della nuova directory e selezionare OK.
In app\src\main\res\rawcreare un nuovo file JSON denominato auth_config_native_auth.json.

Nel file auth_config_native_auth.json aggiungere le configurazioni MSAL seguenti:

{ 
  "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 
  } 
} 
 //...

Sostituire i segnaposto seguenti con i valori del tenant ottenuti dall'interfaccia di amministrazione di Microsoft Entra:
- Sostituire il segnaposto Enter_the_Application_Id_Here con l'ID applicazione (client) dell'app registrata in precedenza.
- Sostituire Enter_the_Tenant_Subdomain_Here con il sottodominio della directory (tenant). Ad esempio, se il dominio primario del tenant è contoso.onmicrosoft.com, usare contoso. Se non si dispone del nome del tenant, vedere come leggere i dettagli del tenant.
I tipi di verifica sono un elenco di valori che l'app usa per notificare a Microsoft Entra il metodo di autenticazione supportato.
- Per i flussi di iscrizione e di accesso con passcode monouso di posta elettronica usare ["oob"].
- Per i flussi di iscrizione e di accesso con posta elettronica e password usare ["oob","password"].
- Per la reimpostazione della password self-service usare ["oob"].
Altre informazioni sui tipi di verifica.

Facoltativo: configurazione della registrazione

Abilitare la registrazione durante la creazione dell'app creando un callback di registrazione, in modo che l'SDK possa restituire i log.

import com.microsoft.identity.client.Logger

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

Per configurare il logger è necessario aggiungere una sezione nel file di configurazione, auth_config_native_auth.json:

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

logcat_enabled: abilita la funzionalità di registrazione della libreria.
pii_enabled: specifica se i messaggi contenenti dati personali o i dati dell'organizzazione vengono registrati. Se impostato su falso, i log non conterranno dati personali. Se impostato su vero, i log possono contenere dati personali.
log_level: consente di decidere il livello di registrazione da applicare. Android supporta i livelli di log seguenti:
1. ERROR
2. AVVISO
3. INFO
4. DETTAGLIATO

Per altre informazioni sulla registrazione MSAL vedere Registrazione in MSAL per Android.

Creare un'istanza dell’SDK MSAL per l'autenticazione nativa

Nel metodo onCreate() creare un'istanza MSAL in modo che l'app possa eseguire l'autenticazione con il tenant tramite l'autenticazione nativa. Il metodo createNativeAuthPublicClientApplication() restituisce un'istanza denominata authClient. Passare il file di configurazione JSON creato in precedenza come parametro.

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

Il codice deve essere simile al frammento di codice seguente:

    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" 
        } 
    }

Recuperare l'account memorizzato nella cache usando getCurrentAccount(), che restituisce un oggetto accountResult.
Se viene trovato un account in persistenza, usare GetAccountResult.AccountFound per visualizzare uno stato di accesso.
In caso contrario, usare GetAccountResult.NoAccountFound per visualizzare uno stato di disconnessione.

Assicurarsi di includere le istruzioni di importazione. Android Studio deve includere automaticamente le istruzioni di importazione.

Passaggio successivo

Esercitazione: Aggiungere l'iscrizione a un'app per dispositivi mobili Android usando l'autenticazione nativa

Condividi tramite