Iniciar sessão na aplicação iOS (Swift) para autenticação - Microsoft Entra External ID

Artigo
05/22/2024

Este é o terceiro tutorial da série de tutoriais que orienta você sobre como entrar em usuários usando o Microsoft Entra External ID.

Neste tutorial, você:

Iniciar sessão utilizador.
Sair do usuário.

Pré-requisitos

Tutorial: Preparar seu aplicativo iOS (Swift) para autenticação

Você tem duas opções principais para entrar em usuários usando a Biblioteca de Autenticação da Microsoft (MSAL) para iOS: adquirir tokens de forma interativa ou silenciosa.

Para entrar no usuário interativamente, use o seguinte código:
```
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)
    }
}
```
O código primeiro verifica se o contexto do aplicativo e os parâmetros de exibição da Web estão disponíveis. Em seguida, ele atualiza o log para indicar que está adquirindo o token interativamente. Em seguida, ele configura parâmetros para aquisição de token interativo, especificando os escopos e parâmetros de exibição da Web. Ele também define o tipo de prompt para selecionar uma conta.

Depois, ele chama o acquireToken método no contexto do aplicativo com os parâmetros definidos. No manipulador de conclusão, ele verifica se há erros. Se for encontrado um erro, ele atualiza o log com a mensagem de erro. Se for bem-sucedido, ele recupera o token de acesso do resultado, atualiza o log com o token e atualiza a conta atual.

Depois que seu aplicativo adquirir um token de acesso, você poderá recuperar as declarações associadas à conta atual. Para fazer isso, use o seguinte trecho de código:
```
let claims = result.account.accountClaims
let preferredUsername = claims?["preferred_username"] as? String
```
O código lê as declarações da conta acessando a accountClaims propriedade do result.account objeto. Em seguida, recupera o valor da declaração "preferred_username" do dicionário de declarações e atribui-o preferredUsername à variável.

Para entrar no usuário silenciosamente, use o seguinte código:

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

O código inicia o processo de aquisição de tokens silenciosamente. Primeiro, tenta carregar a conta corrente. Se uma conta corrente for encontrada, ela procede à aquisição do token silenciosamente usando essa conta. Se nenhuma conta atual for encontrada, ele atualiza o log para indicar que nenhum token foi encontrado e sugere tentar adquirir um token interativamente primeiro.

No código acima, estamos chamando duas funções, loadCurrentAccount e acquireTokenSilently. A loadCurrentAccount função deve ter o seguinte código:

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

O código usa MSAL para iOS para carregar a conta atual. Ele verifica se há erros e atualiza o log de acordo. Se uma conta corrente for encontrada, ela a atualiza e tenta adquirir tokens silenciosamente. Se existir uma conta anterior, ela registra o logout. Se nenhuma conta for encontrada, ele limpa o token de acesso. Finalmente, ele executa um bloco de conclusão, se fornecido.

A acquireTokenSilently função deve conter o seguinte código:

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

Esta função usa o MSAL para iOS para adquirir silenciosamente um token para uma conta existente. Depois de verificar o applicationContext, ele registra o processo de aquisição do token. Usando MSALSilentTokenParameters, ele define os parâmetros necessários. Em seguida, tenta adquirir o token silenciosamente. Se houver erros, ele verifica os requisitos de interação do usuário, iniciando um processo interativo, se necessário. Após o sucesso, ele atualiza a accessToken propriedade e registra o token atualizado, concluindo ativando o botão de sair.

Sair do usuário

Para sair de um usuário do seu aplicativo iOS (Swift) usando o MSAL para iOS, use o seguinte código:

   @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)
            })
            
        }
    }

O código verifica a existência do applicationContext, currentAccounte webViewParamaters. Em seguida, ele registra o processo de saída. O código remove todos os tokens do cache da conta fornecida. Dependendo do modo de dispositivo atual, ele determina se deve sair do navegador. Após a conclusão, ele atualiza o texto de registro de acordo. Se ocorrer um erro durante o processo de saída, ele registrará a mensagem de erro. Após a saída bem-sucedida, ele atualiza o token de acesso para uma cadeia de caracteres vazia e limpa a conta atual.

Próximos passos

Tutorial: Chame uma API da Web protegida no aplicativo iOS (Swift).

Partilhar via

Pré-requisitos

Sair do usuário

Próximos passos

Comentários

Recursos adicionais

Partilhar via

Tutorial: Iniciar sessão de utilizadores na aplicação móvel iOS (Swift)

Pré-requisitos

Utilizador de início de sessão

Sair do usuário

Próximos passos

Comentários

Recursos adicionais