Dela via

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

Gäller för: vit cirkel med en grå X-symbol. arbetskraftsaktörer grön cirkel med en vit bockmarkeringssymbol. externa klienter (läs mer)

Den här självstudien visar hur du registrerar en användare med e-postlösenord eller användarnamn (e-post) och lösenord och samlar in användarattribut i din Android-mobilapp med inbyggd autentisering.

I den här handledningen kommer du att:

  • Registrera en användare med ett engångslösenord via e-post eller ett användarnamn (e-post) och lösenord.
  • Samla in användarattribut under registreringen.
  • Hantera fel vid registrering.

Förutsättningar

Registrera en användare

Om du vill registrera en användare med e-postlösenord eller användarnamn (e-post) och lösenord samlar du in ett e-postmeddelande från användaren och skickar sedan ett e-postmeddelande med ett engångslösenord till användaren. Användaren anger ett giltigt engångslösenord för e-post för att verifiera sitt användarnamn.

Om du vill registrera en användare måste du:

  1. Skapa ett användargränssnitt (UI) för att:

    • Samla in ett e-postmeddelande från användaren. Lägg till validering i dina indata för att se till att användaren anger en giltig e-postadress.
    • Samla in ett lösenord om du registrerar dig med användarnamn (e-post) och lösenord.
    • Samla in ett engångslösenord för e-post från användaren.
    • Samla in användarattribut om det behövs.
    • Skicka engångslösenordet igen (rekommenderas).
    • Starta registreringsflödet.

  2. I din app lägger du till en knapp vars select-händelse utlöser följande kodfragment:

    CoroutineScope(Dispatchers.Main).launch {
     val parameters = NativeAuthSignUpParameters(username = email)
     // Assign 'password' param if you sign in with username (email) and password
     // parameters.password = password
     val actionResult: SignUpResult = authClient.signUp(parameters)

     if (actionResult is SignUpResult.CodeRequired) {
         val nextState = actionResult.nextState
         val submitCodeActionResult = nextState.submitCode(
            code = code
         )
         if (submitCodeActionResult is SignUpResult.Complete) {
            // Handle sign up success
         }
    }
}
    • Använd SDK:ts instansmetod signUp(parameters) för att starta registreringsflödet.
    • Om du vill registrera dig med användarnamn (e-postadress) och lösenord skapar du en instans av klassen NativeAuthSignUpParameters och tilldelar ditt användarnamn och lösenord.
    • Registreringsparametern usernameär den e-postadress som du samlar in från användaren.
    • I det vanligaste scenariot returnerar signUp(parameters) ett resultat, SignUpResult.CodeRequired, vilket indikerar att SDK förväntar sig att appen anger engångskoden som skickats till användarens e-postadress.
    • Objektet SignUpResult.CodeRequired innehåller en ny tillståndsreferens som vi kan hämta via actionResult.nextState.
    • Det nya tillståndet ger oss tillgång till två nya metoder:
      • submitCode() skickar e-postlösenordet som appen samlar in från användaren.
      • resendCode() skickar e-postmeddelandet engångslösenordet igen om användaren inte tar emot koden.
    • submitCode() Returnerar SignUpResult.Complete, vilket anger att flödet är klart och att användaren har registrerats.
    • signUp(parameters) kan också returnera SignUpError för att ange att ett fel har inträffat.

Samla in användarattribut under registreringen

Oavsett om du registrerar en användare med ett engångslösenord via e-post eller med användarnamn (e-post) och lösenord, kan du samla in användarattribut innan ett användarkonto skapas.

  • NativeAuthSignUpParameters-instansen tar emot en attributes-parameter.

        CoroutineScope(Dispatchers.Main).launch {
        val parameters = NativeAuthSignUpParameters(username = email)
        // Assign 'password' param if you sign in with username (email) and password
        // parameters.password = password
        parameters.attributes = userAttributes
        val actionResult: SignUpResult = authClient.signUp(parameters)
        //...
    }

  • Android SDK tillhandahåller en verktygsklass UserAttribute.Builder som du använder för att skapa användarattribut. Om du till exempel vill skicka användarattribut för stad och land använder du följande kodfragment för att skapa variabeln userAttributes :

         val userAttributes = UserAttributes.Builder ()
    .country(country) 
    .city(city) 
    .build()

    Metodnamnen UserAttribute.Builder i klassen är samma som de programmerbara namnen på de användarattribut som de skapar. Läs mer om Attribute Builder för Android SDK.

  • Metoden signUp(parameters) kan returnera SignUpResult.AttributesRequired för att indikera att appen måste skicka ett eller flera obligatoriska attribut innan Microsoft Entra skapar ett konto. Dessa attribut konfigureras av administratören som obligatoriska i administrationscentret för Microsoft Entra. Microsoft Entra begär inte uttryckligen valfria användarattribut.

  • Resultatet SignUpResult.AttributesRequired innehåller en requiredAttributes parameter. requiredAttributes är en lista över RequiredUserAttribute objekt som innehåller information om de användarattribut som appen behöver skicka. Om du vill hantera actionResult is SignUpResult.AttributesRequiredanvänder du följande kodfragment:

    val parameters = NativeAuthSignUpParameters(username = email)
// Assign 'password' param if you sign in with username (email) and password
// parameters.password = password
parameters.attributes = userAttributes
val actionResult: SignUpResult = authClient.signUp(parameters)

if (actionResult is SignUpResult.AttributesRequired) {
        val requiredAttributes = actionResult.requiredAttributes 
        // Handle "attributes required" result 
        val nextState = actionResult.nextState
        nextState.submitAttributes(
            attributes = moreAttributes
        )
}

Hantera problem med registrering

Under registreringen lyckas inte alla åtgärder. Användaren kan till exempel försöka registrera sig med en e-postadress som redan används eller skicka ett ogiltigt engångslösenord för e-post.

Hantera fel vid start av registrering

Om du vill hantera fel för signUp() metoden använder du följande kodfragment:

 val parameters = NativeAuthSignUpParameters(username = email)
 // Assign 'password' param if you sign in with username (email) and password
 // parameters.password = password
val actionResult: SignUpResult = authClient.signUp(parameters)

if (actionResult is SignUpResult.CodeRequired) {
    // Next step: submit code
} else if (actionResult is SignUpError) {
     when {
         actionResult.isUserAlreadyExists() -> {
             // Handle "user already exists" error
         }
         else -> {
             // Handle other errors
         }
     }
}

  • signUp(parameters) kan returnera SignUpError.

  • SignUpError anger ett misslyckat åtgärdsresultat som returneras av signUp() och inte innehåller någon referens till det nya tillståndet.

  • Om actionResult is SignUpErrortillhandahåller MSAL Android SDK verktygsmetoder så att du kan analysera de specifika felen ytterligare:

    • Metoden isUserAlreadyExists() kontrollerar om användarnamnet redan har använts för att skapa ett konto.
    • isInvalidAttributes() kontrollerar om ett eller flera attribut som appen har skickat underkändes i valideringen, till exempel en felaktig datatyp. Den innehåller en invalidAttributes parameter, som är en lista över alla attribut som apparna skickade, men som misslyckades med valideringen.
    • isInvalidPassword() kontrollera att lösenordet är ogiltigt, till exempel när lösenordet inte uppfyller alla krav på lösenordskomplexitet. Läs mer om Microsoft Entras lösenordsprinciper
    • isInvalidUsername() kontrollera att användarnamnet är ogiltigt, till exempel när användarens e-post är ogiltig.
    • isBrowserRequired() kontrollerar om det finns ett behov av en webbläsare (fallback till webbläsare), för att slutföra autentiseringsflödet. Det här scenariot inträffar när intern autentisering inte räcker för att slutföra autentiseringsflödet. En administratör konfigurerar till exempel e-post och lösenord som autentiseringsmetod, men appen kan inte skicka lösenord som en utmaningstyp eller helt enkelt inte stöder det. Följ stegen i Stöd för webbfallback i Android-appen för att hantera scenariot när det inträffar.
    • isAuthNotSupported() kontrollerar om appen skickar en utmaningstyp som Microsoft Entra inte stöder, det är ett annat utmaningstypvärde än oob eller lösenord. Läs mer om utmaningstyper.

    Meddela användaren att e-postmeddelandet redan används eller att vissa attribut är ogiltiga med hjälp av ett eget meddelande i appens användargränssnitt.

  • Om du vill hantera felet med ogiltiga attribut använder du följande kodfragment:

    val parameters = NativeAuthSignUpParameters(username = email)
// Assign 'password' param if you sign in with username (email) and password
// parameters.password = password
parameters.attributes = userAttributes
val actionResult: SignUpResult = authClient.signUp(parameters)

if (actionResult is SignUpError && actionResult.isInvalidAttributes()) {
    val invalidAttributes = actionResult.invalidAttributes

    // Handle "invalid attributes" error, this time submit valid attributes
    val parameters = NativeAuthSignUpParameters(username = email)
    // Assign 'password' param if you sign in with username (email) and password
    // parameters.password = password
    parameters.attributes = userAttributes
    authClient.signUp(parameters)
} 
//...

Hantera fel vid inlämning av engångslösenord via e-post

Om du vill hantera fel för submitCode() metoden använder du följande kodfragment:

val submitCodeActionResult = nextState.submitCode(
    code = code
)
if (submitCodeActionResult is SignUpResult.Complete) {
    // Sign up flow complete, handle success state.
} else if (submitCodeActionResult is SubmitCodeError) {
    // Handle errors under SubmitCodeError
     when {
         submitCodeActionResult.isInvalidCode() -> {
             // Handle "code invalid" error
         }
         else -> {
             // Handle other errors
         }
     }
}

  • submitCode() kan returnera SubmitCodeError.

  • isInvalidCode() Använd metoden för att söka efter det specifika felet, till exempel att den inskickade koden är ogiltig. I det här fallet måste den tidigare tillståndsreferensen användas för att omformforma åtgärden.

  • Om du vill hämta ett nytt engångslösenord för e-post använder du följande kodfragment:

    val submitCodeActionResult = nextState.submitCode(
    code = code
)
if (submitCodeActionResult is SubmitCodeError && submitCodeActionResult.isInvalidCode()) {
    // Inform the user that the submitted code was incorrect or invalid and ask for a new code to be supplied
    val newCode = retrieveNewCode()
    nextState.submitCode(
        code = newCode
    )
}

Se till att du inkluderar importinstruktionerna. Android Studio ska inkludera importinstruktionerna automatiskt.

Du har slutfört alla nödvändiga steg för att registrera en användare i din app. Skapa och kör ditt program. Om allt är bra bör du kunna registrera användaren med e-post engångslösenord eller e-post och lösenord.

Valfritt: Logga in efter ett registreringsflöde

Efter ett lyckat registreringsflöde kan du logga in en användare utan att initiera ett inloggningsflöde. Läs mer i artikeln Självstudie: Logga in användare efter registrering i Android .

Nästa steg

Självstudie: Lägg till inloggning och logga ut med engångslösenord för e-post i Android-appen.