Självstudie: Förbereda din Android-mobilapp för intern autentisering

Artikel
05/30/2024

Den här självstudien visar hur du lägger till inbyggt SDK för microsoft-autentiseringsbibliotek (MSAL) i en Android-mobilapp.

I den här självstudien lär du dig att:

Lägg till MSAL-beroenden.
Skapa en konfigurationsfil.
Skapa MSAL SDK-instans.

Förutsättningar

Om du inte redan har gjort det följer du anvisningarna i Logga in användare i exempelmobilappen För Android (Kotlin) med inbyggd autentisering och registrera en app i din externa klientorganisation. Se till att du slutför följande steg:
- Registrera ett program.
- Aktivera offentliga klient- och interna autentiseringsflöden.
- Bevilja API-behörigheter.
- Skapa ett användarflöde.
- Associera appen med användarflödet.
Ett Android-projekt. Om du inte har ett Android-projekt skapar du det.

Lägga till MSAL-beroenden

Öppna projektet i Android Studio eller skapa ett nytt projekt.

Öppna programmets build.gradle och lägg till följande beroenden:

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

I Android Studio väljer du Filsynkroniseringsprojekt>med Gradle Files.

Skapa en konfigurationsfil

Du skickar de nödvändiga klient-ID:erna, till exempel program-ID:t (klient)-ID:t, till MSAL SDK via en JSON-konfigurationsinställning.

Använd de här stegen för att skapa konfigurationsfilen:

I Android Studio-projektfönstret navigerar du till app\src\main\res.
Högerklicka på res och välj Ny>katalog. Ange raw som nytt katalognamn och välj OK.
I app\src\main\res\raw skapar du en ny JSON-fil med namnet auth_config_native_auth.json.

auth_config_native_auth.json Lägg till följande MSAL-konfigurationer i filen:

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

Ersätt följande platshållare med dina klientvärden som du fick från administrationscentret för Microsoft Entra:
- Enter_the_Application_Id_Here Ersätt platshållaren med programmets (klient)-ID för appen som du registrerade tidigare.
- Enter_the_Tenant_Subdomain_Here Ersätt med underdomänen katalog (klientorganisation). Om din primära klientdomän till exempel är contoso.onmicrosoft.comanvänder du contoso. Om du inte har ditt klientnamn kan du läsa klientinformationen.
Utmaningstyperna är en lista med värden som appen använder för att meddela Microsoft Entra om den autentiseringsmetod som den stöder.
- För registrerings- och inloggningsflöden med engångslösenord för e-post använder du ["oob"].
- För registrerings- och inloggningsflöden med e-post och lösenord använder du ["oob","password"].
- För självbetjäning av lösenordsåterställning (SSPR) använder du ["oob"].
Läs mer om utmaningstyper.

Valfritt: Loggningskonfiguration

Aktivera loggning när appen skapas genom att skapa ett återanrop för loggning, så att SDK:t kan mata ut loggar.

import com.microsoft.identity.client.Logger

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

För att konfigurera loggern måste du lägga till ett avsnitt i konfigurationsfilen: auth_config_native_auth.json

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

logcat_enabled: Aktiverar loggningsfunktionen i biblioteket.
pii_enabled: Anger om meddelanden som innehåller personliga data eller organisationsdata loggas. När värdet är falskt innehåller loggarna inte personliga data. När det är inställt på true kan loggarna innehålla personliga data.
log_level: Använd den för att bestämma vilken loggningsnivå som ska aktiveras. Android stöder följande loggnivåer:
1. ERROR
2. WARNING
3. INFO
4. VERBOSE

Mer information om MSAL-loggning finns i Loggning i MSAL för Android.

Skapa en MSAL SDK-instans för intern autentisering

onCreate() I -metoden skapar du en MSAL-instans så att appen kan utföra autentisering med din klientorganisation via intern autentisering. Metoden createNativeAuthPublicClientApplication() returnerar en instans med namnet authClient. Skicka JSON-konfigurationsfilen som du skapade tidigare som en parameter.

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

Koden bör se ut ungefär så här:

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

Hämta det cachelagrade kontot med hjälp getCurrentAccount()av , som returnerar ett objekt, accountResult.
Om ett konto hittas i beständighet kan du använda GetAccountResult.AccountFound för att visa ett loggat tillstånd.
Annars kan du använda GetAccountResult.NoAccountFound för att visa ett utloggningstillstånd.

Se till att du inkluderar importinstruktionerna. Android Studio bör inkludera importinstruktionerna automatiskt.

Gå vidare

Självstudie: Lägga till registrering i en Android-mobilapp med inbyggd autentisering

Dela via