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

Artikel
03/05/2025

Gäller för: vit cirkel med en grå X-symbol. Workforce-klientorganisationer grön cirkel med en vit bockmarkeringssymbol. externa klienter (lära dig mer)

Den här handledningen visar hur du lägger till Microsoft Authentication Library (MSAL) som ett inbyggt autentiserings-SDK i en mobilapp för Android.

I den här handledningen 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 en applikation.
- 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 File>Sync Project 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 New>Directory. Ange raw som nytt katalognamn och välj OK.
I app\src\main\res\rawskapar du en ny JSON-fil med namnet auth_config_native_auth.json.

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

{ 
  "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:
- Ersätt platshållaren Enter_the_Application_Id_Here med program-ID:t (klient) för appen som du registrerade tidigare.
- Ersätt Enter_the_Tenant_Subdomain_Here 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 lär du dig att 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änad lösenordsåterställning (SSPR) använder du ["oob"].
Läs mer 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 loggaren 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. FEL
2. VARNING
3. INFORMATION
4. MÅNGORDIG

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

Skapa en MSAL SDK-instans för intern autentisering

I metoden onCreate() 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 av getCurrentAccount(), som returnerar ett objekt accountResult.
Om ett konto hittas i beständighet använder du 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.

Nästa steg

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

Dela via