Samouczek: przygotowywanie aplikacji mobilnej systemu Android do uwierzytelniania natywnego

Artykuł
03/05/2025

Dotyczy: Biały okrąg z szarym symbolem X. Najemcy Workforce Zielony okrąg z białym znacznikiem wyboru. Zewnętrzni najemcy (dowiedzieć się więcej)

W tym samouczku pokazano, jak dodać natywne SDK uwierzytelniania MSAL do aplikacji mobilnej na Androida.

Z tego samouczka dowiesz się, jak wykonywać następujące działania:

Dodaj zależności MSAL.
Utwórz plik konfiguracji.
Utwórz wystąpienie MSAL SDK.

Warunki wstępne

Jeśli jeszcze tego nie zrobiono, postępuj zgodnie z instrukcjami w Zaloguj użytkowników w przykładowej aplikacji mobilnej na Androida (Kotlin) przy użyciu natywnego uwierzytelniania i zarejestruj aplikację w zewnętrznym dzierżawcy. Upewnij się, że wykonasz następujące kroki:
- Rejestrowanie aplikacji.
- Włącz przepływy uwierzytelniania dla klientów publicznych i natywnych.
- Udziel uprawnień API.
- Utwórz przepływ użytkownika.
- Skojarz aplikację z przepływem użytkownika.
Projekt systemu Android. Jeśli nie masz projektu systemu Android, utwórz go.

Dodaj zależności MSAL

Otwórz projekt w programie Android Studio lub utwórz nowy projekt.

Otwórz w aplikacji element build.gradle i dodaj następujące zależności:

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

W programie Android Studio wybierz File>Sync Project with Gradle Files.

Tworzenie pliku konfiguracji

Wymagane identyfikatory dzierżawy, takie jak identyfikator aplikacji (klienta), są przekazywane do zestawu SDK biblioteki MSAL za pomocą ustawienia konfiguracji JSON.

Wykonaj następujące kroki, aby utworzyć plik konfiguracji:

W okienku projektu programu Android Studio przejdź do app\src\main\res.
Kliknij prawym przyciskiem myszy res i wybierz pozycję New>Directory. Wprowadź raw jako nazwę nowego katalogu i wybierz pozycję OK.
W app\src\main\res\rawutwórz nowy plik JSON o nazwie auth_config_native_auth.json.

W pliku auth_config_native_auth.json dodaj następujące konfiguracje biblioteki MSAL:

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

Zastąp następujące symbole wartościami dzierżawy uzyskanymi z centrum administracyjnego Microsoft Entra:
- Zastąp symbol zastępczy Enter_the_Application_Id_Here identyfikatorem aplikacji (klienta), którą zarejestrowano wcześniej.
- Zastąp Enter_the_Tenant_Subdomain_Here subdomeną katalogu (dzierżawy). Jeśli na przykład domena podstawowa dzierżawy to contoso.onmicrosoft.com, użyj contoso. Jeśli nie masz nazwy dzierżawcy, dowiedz się, jak sprawdzić szczegóły swojego dzierżawcy.
Typy wyzwań to lista wartości, których aplikacja używa do powiadamiania firmy Microsoft Entra o obsługiwanej przez nią metodzie uwierzytelniania.
- W przypadku procesów rejestracji i logowania przy użyciu jednorazowego kodu przesyłanego e-mailem użyj ["oob"].
- W przypadku przepływów rejestracji i logowania przy użyciu poczty e-mail i hasła użyj ["oob","password"].
- W przypadku samoobsługowego resetowania hasła (SSPR) użyj ["oob"].
Dowiedz się więcej o rodzajach wyzwań.

Opcjonalnie: Konfiguracja rejestrowania

Włącz rejestrowanie podczas tworzenia aplikacji, tworząc wywołanie zwrotne do rejestrowania, aby zestaw SDK mógł wyświetlać logi.

import com.microsoft.identity.client.Logger

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

Aby skonfigurować rejestrator, należy dodać sekcję w pliku konfiguracji, auth_config_native_auth.json:

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

logcat_enabled: Włącza funkcjonalność rejestrowania biblioteki.
pii_enabled: określa, czy komunikaty zawierające dane osobowe, czy dane organizacyjne są rejestrowane. W przypadku ustawienia wartości false dzienniki nie będą zawierać danych osobowych. Po ustawieniu wartości true dzienniki mogą zawierać dane osobowe.
log_level: Użyj tego, aby zdecydować, który poziom rejestrowania aktywować. System Android obsługuje następujące poziomy dziennika:
1. BŁĄD
2. OSTRZEŻENIE
3. INFORMACJA
4. GADATLIWY

Aby uzyskać więcej informacji na temat rejestrowania w MSAL, zobacz Logowanie do MSAL dla Androida.

Utwórz instancję natywnego uwierzytelniania MSAL SDK

W metodzie onCreate() utwórz wystąpienie MSAL, aby aplikacja mogła przeprowadzić uwierzytelnianie w ramach dzierżawy przy użyciu uwierzytelniania natywnego. Metoda createNativeAuthPublicClientApplication() zwraca wystąpienie o nazwie authClient. Przekaż utworzony wcześniej plik konfiguracji JSON jako parametr.

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

Kod powinien wyglądać podobnie do poniższego fragmentu kodu:

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

Pobierz buforowane konto przy użyciu getCurrentAccount(), który zwraca obiekt accountResult.
Jeśli konto znajduje się w pamięci trwałej, użyj GetAccountResult.AccountFound, aby wyświetlić stan zalogowania.
W przeciwnym razie użyj GetAccountResult.NoAccountFound, aby wyświetlić stan wylogowania.

Upewnij się, że dołączysz instrukcje importowania. Program Android Studio powinien automatycznie dołączać instrukcje importowania.

Następny krok

Samouczek: dodawanie rejestracji w aplikacji mobilnej systemu Android przy użyciu natywnego uwierzytelniania

Udostępnij za pośrednictwem