Dela via

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

  • Artikel

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 självstudien lär du dig att:

  • Registrera en användare med e-postlösenord eller användarnamn (e-post) och lösenord via e-post.
  • Samla in användarattribut under registreringen.
  • Hantera registreringsfel.

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 actionResult = authClient.signUp(
        username = emailAddress
        //password = password, Pass 'password' param if you sign up with username (email) and password
    )
    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(username) för att starta registreringsflödet.
      • Om du vill registrera dig med användarnamn (e-postadress) och lösenord skickar du lösenordsparametern signUp till funktionen . signUp(username, password)
    • Metodens parameter, username, är sedan den e-postadress som du samlar in från användaren.
    • I det vanligaste scenariot signUp(username) returnerar eller signUp(username, password) ett resultat, SignUpResult.CodeRequired, vilket anger att SDK förväntar sig att appen skickar e-postmeddelandet engångslösenordet som skickas 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-postmeddelandet engångslö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.
    • Eller signUp(username) signUp(username, password) kan också återgå SignUpError till att ange att ett fel har inträffat.

Samla in användarattribut under registreringen

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

  • Metoden signUp() accepterar en attributes parameter, som signUp(username, attributes):

        CoroutineScope(Dispatchers.Main).launch {
        val actionResult = authClient.signUp(
            username = emailAddress,
            attributes = userAttributes
            //password = password, Pass 'password' param if you sign up with username (email) and password
        )
        //...
    }

  • 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(username, attributes) eller signUp(username, attributes, password)kan returneras 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 actionResult = authClient.signUp(
    username = email,
    attributes = attributes
    //password = password, Pass 'password' param if you sign up with username (email) and password
)
if (actionResult is SignUpResult.AttributesRequired) {
        val requiredAttributes = actionResult.requiredAttributes 
        // Handle "attributes required" result 
        val nextState = actionResult.nextState
        nextState.submitAttributes(
            attributes = moreAttributes
        )
}

Hantera registreringsfel

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 startregistreringsfel

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

val actionResult = authClient.signUp(
    username = email
)
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(username, attributes) eller signUp(username, password, attributes) 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 skickade misslyckad validering, till exempel fel 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 behovet av en webbläsare (webbåterställning) 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. Till exempel konfigurerar en administratör e-post och lösenord som autentiseringsmetod, men appen kan inte skicka lösenord som en utmaningstyp eller helt enkelt inte stöder det. Använd stegen i Stöd för webbåterställning i Android-appen för att hantera scenariot när det händer.
    • 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 actionResult = authClient.signUp(
    username = email,
    attributes = attributes
    //password = password, Pass 'password' param if you sign up with username (email) and password
)
if (actionResult is SignUpError && actionResult.isInvalidAttributes()) {
    val invalidAttributes = actionResult.invalidAttributes
    // Handle "invalid attributes" error, this time submit valid attributes
    authClient.signUp(
        username = emailAddress,
        attributes = resubmittedAttributes
        //password = password, Pass 'password' param if you sign up with username (email) and password
    )
} 
//...

Hantera ett engångslösenord för skicka 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 bör 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.