Gebruikers aanmelden voor iOS-app (Swift) voor verificatie - Microsoft Entra External ID

Artikel
05/22/2024

Dit is de derde zelfstudie in de reeks zelfstudies die u begeleidt bij het aanmelden van gebruikers met behulp van Microsoft Entra Externe ID.

In deze zelfstudie gaat u:

Gebruiker aanmelden.
Afmeldingsgebruiker.

Vereisten

Zelfstudie: Uw iOS-app (Swift) voorbereiden voor verificatie

U hebt twee belangrijke opties voor het aanmelden van gebruikers met behulp van Microsoft Authentication Library (MSAL) voor iOS: tokens interactief of op de achtergrond verkrijgen.

Gebruik de volgende code om de gebruiker interactief aan te melden:
```
acquireTokenInteractively() {
    guard let applicationContext = self.applicationContext else { return }
    guard let webViewParameters = self.webViewParamaters else { return }

    updateLogging(text: "Acquiring token interactively...")

    let parameters = MSALInteractiveTokenParameters(scopes: Configuration.kScopes, webviewParameters: webViewParameters)
    parameters.promptType = .selectAccount

    applicationContext.acquireToken(with: parameters) { (result, error) in

        if let error = error {

            self.updateLogging(text: "Could not acquire token: \(error)")
            return
        }

        guard let result = result else {

            self.updateLogging(text: "Could not acquire token: No result returned")
            return
        }

        self.accessToken = result.accessToken
        self.updateLogging(text: "Access token is \(self.accessToken)")
        self.updateCurrentAccount(account: result.account)
    }
}
```
De code controleert eerst of de parameters voor de toepassingscontext en webweergave beschikbaar zijn. Vervolgens wordt de logboekregistratie bijgewerkt om aan te geven dat het token interactief wordt opgehaald. Vervolgens worden parameters ingesteld voor interactieve tokenverwerving, waarbij de bereiken en webweergaveparameters worden opgegeven. Ook wordt het prompttype ingesteld om een account te selecteren.

Daarna wordt de acquireToken methode in de toepassingscontext aangeroepen met de gedefinieerde parameters. In de voltooiingshandler wordt gecontroleerd op eventuele fouten. Als er een fout optreedt, wordt de logboekregistratie bijgewerkt met het foutbericht. Als dit lukt, wordt het toegangstoken opgehaald uit het resultaat, wordt de logboekregistratie bijgewerkt met het token en wordt het huidige account bijgewerkt.

Zodra uw app een toegangstoken heeft verkregen, kunt u de claims ophalen die zijn gekoppeld aan het huidige account. Gebruik hiervoor het volgende codefragment:
```
let claims = result.account.accountClaims
let preferredUsername = claims?["preferred_username"] as? String
```
De code leest claims uit het account door toegang te krijgen tot de accountClaims eigenschap van het result.account object. Vervolgens wordt de waarde van de claim 'preferred_username' opgehaald uit de claimwoordenlijst en wordt deze toegewezen aan de preferredUsername variabele.

Gebruik de volgende code om de gebruiker op de achtergrond aan te melden:

func acquireTokenSilently() {
    self.loadCurrentAccount { (account) in

        guard let currentAccount = account else {

            self.updateLogging(text: "No token found, try to acquire a token interactively first")
            return
        }

        self.acquireTokenSilently(currentAccount)
    }
}

De code initieert het proces van het verkrijgen van tokens op de achtergrond. Eerst wordt geprobeerd het huidige account te laden. Als er een huidig account wordt gevonden, wordt het token op de achtergrond verkregen met behulp van dat account. Als er geen huidig account wordt gevonden, wordt de logboekregistratie bijgewerkt om aan te geven dat er geen token wordt gevonden en wordt voorgesteld om eerst interactief een token te verkrijgen.

In de bovenstaande code roepen we twee functies aan, loadCurrentAccount en acquireTokenSilently. De loadCurrentAccount functie moet de volgende code hebben:

func loadCurrentAccount(completion: AccountCompletion? = nil) {

    guard let applicationContext = self.applicationContext else { return }

    let msalParameters = MSALParameters()
    msalParameters.completionBlockQueue = DispatchQueue.main

    // Note that this sample showcases an app that signs in a single account at a time
    applicationContext.getCurrentAccount(with: msalParameters, completionBlock: { (currentAccount, previousAccount, error) in

        if let error = error {
            self.updateLogging(text: "Couldn't query current account with error: \(error)")
            return
        }

        if let currentAccount = currentAccount {

            self.updateCurrentAccount(account: currentAccount)
            self.acquireTokenSilently(currentAccount)

            if let completion = completion {
                completion(self.currentAccount)
            }

            return
        }

        // If testing with Microsoft's shared device mode, see the account that has been signed out from another app. More details here:
        // https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-ios-shared-devices
        if let previousAccount = previousAccount {

            self.updateLogging(text: "The account with username \(String(describing: previousAccount.username)) has been signed out.")

        } else {

            self.updateLogging(text: "")
        }

        self.accessToken = ""
        self.updateCurrentAccount(account: nil)

        if let completion = completion {
            completion(nil)
        }
    })
}

De code gebruikt MSAL voor iOS om het huidige account te laden. Het controleert op fouten en werkt de logboekregistratie dienovereenkomstig bij. Als een huidig account wordt gevonden, wordt het bijgewerkt en wordt geprobeerd tokens op de achtergrond te verkrijgen. Als er een eerder account bestaat, wordt de afmelding in een logboek opgeslagen. Als er geen accounts worden gevonden, wordt het toegangstoken gewist. Ten slotte wordt een voltooiingsblok uitgevoerd, indien opgegeven.

De acquireTokenSilently functie moet de volgende code bevatten:

func acquireTokenSilently(_ account : MSALAccount) {
    guard let applicationContext = self.applicationContext else { return }

    /**

     Acquire a token for an existing account silently

     - forScopes:           Permissions you want included in the access token received
     in the result in the completionBlock. Not all scopes are
     guaranteed to be included in the access token returned.
     - account:             An account object that we retrieved from the application object before that the
     authentication flow will be locked down to.
     - completionBlock:     The completion block that will be called when the authentication
     flow completes, or encounters an error.
     */

    updateLogging(text: "Acquiring token silently...")

    let parameters = MSALSilentTokenParameters(scopes: Configuration.kScopes, account: account)

    applicationContext.acquireTokenSilent(with: parameters) { (result, error) in

        if let error = error {

            let nsError = error as NSError

            // interactionRequired means we need to ask the user to sign-in. This usually happens
            // when the user's Refresh Token is expired or if the user has changed their password
            // among other possible reasons.

            if (nsError.domain == MSALErrorDomain) {

                if (nsError.code == MSALError.interactionRequired.rawValue) {

                    DispatchQueue.main.async {
                        self.acquireTokenInteractively()
                    }
                    return
                }
            }

            self.updateLogging(text: "Could not acquire token silently: \(error)")
            return
        }

        guard let result = result else {

            self.updateLogging(text: "Could not acquire token: No result returned")
            return
        }

        self.accessToken = result.accessToken
        self.updateLogging(text: "Refreshed Access token is \(self.accessToken)")
        self.updateSignOutButton(enabled: true)
    }
}

Deze functie gebruikt MSAL voor iOS om op de achtergrond een token te verkrijgen voor een bestaand account. Nadat u de applicationContextverificatie hebt uitgevoerd, wordt het proces voor het ophalen van tokens in een logboek opgeslagen. Hiermee MSALSilentTokenParametersworden de benodigde parameters gedefinieerd. Vervolgens wordt geprobeerd het token op de achtergrond te verkrijgen. Als er fouten zijn, wordt gecontroleerd op vereisten voor gebruikersinteractie, waardoor zo nodig een interactief proces wordt gestart. Wanneer het is gelukt, wordt de accessToken eigenschap bijgewerkt en wordt het vernieuwde token geregistreerd. Dit wordt afgesloten door de knop Afmelden in te schakelen.

Gebruiker afmelden

Als u een gebruiker wilt afmelden bij uw iOS-app (Swift) met MSAL voor iOS, gebruikt u de volgende code:

   @IBAction func signOut(_ sender: UIButton) {
        
        guard let applicationContext = self.applicationContext else { return }
        
        guard let account = self.currentAccount else { return }
        
        guard let webViewParamaters = self.webViewParamaters else { return }
        
        updateLogging(text: "Signing out...")
        
        do {
            
            /**
             Removes all tokens from the cache for this application for the provided account
             
             - account:    The account to remove from the cache
             */
            
            let signoutParameters = MSALSignoutParameters(webviewParameters: webViewParamaters)
            
            // If testing with Microsoft's shared device mode, trigger signout from browser. More details here:
            // https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-ios-shared-devices
            
            if (self.currentDeviceMode == .shared) {
                signoutParameters.signoutFromBrowser = true
            } else {
                signoutParameters.signoutFromBrowser = false
            }
            
            applicationContext.signout(with: account, signoutParameters: signoutParameters, completionBlock: {(success, error) in
                
                if let error = error {
                    self.updateLogging(text: "Couldn't sign out account with error: \(error)")
                    return
                }
                
                self.updateLogging(text: "Sign out completed successfully")
                self.accessToken = ""
                self.updateCurrentAccount(account: nil)
            })
            
        }
    }

De code controleert het bestaan van , applicationContextcurrentAccounten webViewParamaters. Vervolgens wordt het afmeldingsproces in een logboek opgeslagen. De code verwijdert alle tokens uit de cache voor het opgegeven account. Afhankelijk van de huidige apparaatmodus wordt bepaald of u zich wilt afmelden bij de browser. Na voltooiing wordt de logboektekst dienovereenkomstig bijgewerkt. Als er een fout optreedt tijdens het afmeldingsproces, wordt het foutbericht in een logboek opgeslagen. Wanneer het afmelden is voltooid, wordt het toegangstoken bijgewerkt naar een lege tekenreeks en wordt het huidige account gewist.

Volgende stappen

Zelfstudie: Een beveiligde web-API aanroepen in de iOS-app (Swift).

Delen via

Vereisten

Gebruiker afmelden

Volgende stappen

Feedback

Aanvullende resources

Delen via

Zelfstudie: Gebruikers aanmelden in de mobiele iOS-app (Swift)

Vereisten

Gebruiker aanmelden

Gebruiker afmelden

Volgende stappen

Feedback

Aanvullende resources