Iniciar sessão de utilizadores Aplicação Android (Kotlin) 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ê:

Utilizador de início de sessão
Sair do usuário

Pré-requisitos

Tutorial: Prepare seu aplicativo Android para autenticação.

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

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

    private fun acquireTokenInteractively() {
    binding.txtLog.text = ""

    if (account != null) {
        Toast.makeText(this, "An account is already signed in.", Toast.LENGTH_SHORT).show()
        return
    }

    /* Extracts a scope array from text, i.e. from "User.Read User.ReadWrite" to ["user.read", "user.readwrite"] */
    val scopes = scopes.lowercase().split(" ")
    val parameters = AcquireTokenParameters.Builder()
        .startAuthorizationFromActivity(this@MainActivity)
        .withScopes(scopes)
        .withCallback(getAuthInteractiveCallback())
        .build()

    authClient.acquireToken(parameters)
}

O código inicia o processo de aquisição de um token interativamente usando o MSAL para Android. Primeiro, ele limpa o campo de log de texto. Em seguida, ele verifica se já há uma conta conectada e, em caso afirmativo, exibe uma mensagem do sistema indicando que uma conta já está conectada e retorna.

Em seguida, ele extrai escopos da entrada de texto e os converte em minúsculas antes de dividi-los em uma matriz. Usando esses escopos, ele cria parâmetros para adquirir um token, incluindo iniciar o processo de autorização da atividade atual e especificar um retorno de chamada. Finalmente, ele chama acquireToken() o cliente de autenticação com os parâmetros construídos para iniciar o processo de aquisição de token.

No código, onde especificamos nosso retorno de chamada, usamos uma função chamada getAuthInteractiveCallback(). A função deve ter o seguinte código:

private fun getAuthInteractiveCallback(): AuthenticationCallback {
    return object : AuthenticationCallback {

        override fun onSuccess(authenticationResult: IAuthenticationResult) {
            /* Successfully got a token, use it to call a protected resource - Web API */
            Log.d(TAG, "Successfully authenticated")
            Log.d(TAG, "ID Token: " + authenticationResult.account.claims?.get("id_token"))
            Log.d(TAG, "Claims: " + authenticationResult.account.claims

            /* Reload account asynchronously to get the up-to-date list. */
            CoroutineScope(Dispatchers.Main).launch {
                accessToken = authenticationResult.accessToken
                getAccount()

                binding.txtLog.text = getString(R.string.log_token_interactive) +  accessToken
            }
        }

        override fun onError(exception: MsalException) {
            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: $exception")

            accessToken = null
            binding.txtLog.text = getString(R.string.exception_authentication) + exception

            if (exception is MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception is MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            }
        }

        override fun onCancel() {
            /* User canceled the authentication */
            Log.d(TAG, "User cancelled login.");
        }
    }
}

O trecho de código define uma função, getAuthInteractiveCallback, que retorna uma instância de AuthenticationCallback. Dentro dessa função, uma classe anônima implementando a AuthenticationCallback interface é criada.

Quando a autenticação é bem-sucedida (onSuccess), ela registra a autenticação bem-sucedida, recupera o token de ID e declarações, atualiza o token de acesso de forma assíncrona usando CoroutineScopee atualiza a interface do usuário com o novo token de acesso. O código recupera o token de ID do authenticationResult e o registra. As declarações no token contêm informações sobre o usuário, como nome, e-mail ou outras informações de perfil. Você pode recuperar as declarações associadas à conta corrente acessando authenticationResult.account.claims.

Se houver um erro de autenticação (onError), ele registra o erro, limpa o token de acesso, atualiza a interface do usuário com a mensagem de erro e fornece tratamento mais específico para MsalClientException e MsalServiceException. Se o usuário cancelar a autenticação (onCancel), ele registrará o cancelamento.

Certifique-se de incluir as instruções de importação. O Android Studio deve incluir as instruções de importação para você automaticamente.

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

    private fun acquireTokenSilently() {
    binding.txtLog.text = ""

    if (account == null) {
        Toast.makeText(this, "No account available", Toast.LENGTH_SHORT).show()
        return
    }

    /* Extracts a scope array from text, i.e. from "User.Read User.ReadWrite" to ["user.read", "user.readwrite"] */
    val scopes = scopes.lowercase().split(" ")
    val parameters = AcquireTokenSilentParameters.Builder()
        .forAccount(account)
        .fromAuthority(account!!.authority)
        .withScopes(scopes)
        .forceRefresh(false)
        .withCallback(getAuthSilentCallback())
        .build()

    authClient.acquireTokenSilentAsync(parameters)
}

O código inicia o processo de aquisição de um token silenciosamente. Primeiro, ele limpa o log de texto. Em seguida, verifica se há uma conta disponível; caso contrário, ele exibe uma mensagem do sistema indicando isso e sai. Em seguida, extrai escopos da entrada de texto, converte-os em minúsculas e os divide em uma matriz.

Usando esses escopos, ele constrói parâmetros para adquirir um token silenciosamente, especificando a conta, autoridade, escopos e retorno de chamada. Finalmente, ele aciona de forma assíncrona no cliente de acquireTokenSilentAsync() autenticação com os parâmetros construídos, iniciando o processo de aquisição silenciosa de tokens.

No código, onde especificamos nosso retorno de chamada, usamos uma função chamada getAuthSilentCallback(). A função deve ter o seguinte código:

private fun getAuthSilentCallback(): SilentAuthenticationCallback {
    return object : SilentAuthenticationCallback {
        override fun onSuccess(authenticationResult: IAuthenticationResult?) {
            Log.d(TAG, "Successfully authenticated")

            /* Display Access Token */
            accessToken = authenticationResult?.accessToken
            binding.txtLog.text = getString(R.string.log_token_silent) + accessToken
        }

        override fun onError(exception: MsalException?) {
            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: $exception")

            accessToken = null
            binding.txtLog.text = getString(R.string.exception_authentication) + exception

            when (exception) {
                is MsalClientException -> {
                    /* Exception inside MSAL, more info inside MsalError.java */
                }
                is MsalServiceException -> {
                    /* Exception when communicating with the STS, likely config issue */
                }
                is MsalUiRequiredException -> {
                    /* Tokens expired or no session, retry with interactive */
                }
            }
        }

    }
}

O código define um retorno de chamada para autenticação silenciosa. Ele implementa a SilentAuthenticationCallback interface, substituindo dois métodos. No método, ele registra a onSuccess autenticação bem-sucedida e exibe o token de acesso.

No método, ele registra falhas onError de autenticação, lida com diferentes tipos de exceções, como MsalClientException e MsalServiceException, e sugere tentar novamente com autenticação interativa, se necessário.

Certifique-se de incluir as instruções de importação. O Android Studio deve incluir as instruções de importação para você automaticamente.

Terminar sessão

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

private fun removeAccount() {
    binding.userName.text = ""
    binding.txtLog.text = ""

    authClient.signOut(signOutCallback())
}

O código remove uma conta do aplicativo. Ele limpa o nome de usuário exibido e o log de texto. Em seguida, ele dispara o processo de saída usando o cliente de autenticação, especificando um retorno de chamada de saída para lidar com a conclusão da operação de saída.

No código, onde especificamos nosso retorno de chamada, usamos uma função chamada signOutCallback(). A função deve ter o seguinte código:

private fun signOutCallback(): ISingleAccountPublicClientApplication.SignOutCallback {
    return object : ISingleAccountPublicClientApplication.SignOutCallback {
        override fun onSignOut() {
            account = null
            updateUI(account)
        }

        override fun onError(exception: MsalException) {
            binding.txtLog.text = getString(R.string.exception_remove_account) + exception
        }
    }
}

O código define um retorno de chamada de saída para uma única conta no aplicativo cliente público. Ele implementa a ISingleAccountPublicClientApplication.SignOutCallback interface, substituindo dois métodos.

onSignOut No método, ele anula a conta atual e atualiza a interface do usuário de acordo. onError No método, ele registra todos os erros que ocorrem durante o processo de saída e atualiza o log de texto com a mensagem de exceção correspondente.

Certifique-se de incluir as instruções de importação. O Android Studio deve incluir as instruções de importação para você automaticamente.

Próximos passos

Tutorial: Chame uma API da Web protegida no aplicativo Android (Kotlin).

Partilhar via

Pré-requisitos

Terminar sessão

Próximos passos

Comentários

Recursos adicionais

Partilhar via

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

Pré-requisitos

Utilizador de início de sessão

Terminar sessão

Próximos passos

Comentários

Recursos adicionais