Tutorial: Preparar seu aplicativo móvel Android para autenticação nativa

Aplica-se a: Locatários externos (saiba mais)

Este tutorial demonstra como adicionar o SDK de autenticação nativa da MSAL (Biblioteca de Autenticação da Microsoft) a um aplicativo móvel Android.

Neste tutorial, você:

Pré-requisitos

• Se ainda não o fez, siga as instruções em Conectar usuários no aplicativo móvel Android (Kotlin) de exemplo usando autenticação nativa e registre um aplicativo no locatário externo. Conclua as seguintes etapas:
  • Registre um aplicativo.
  • Habilite o cliente público e os fluxos de autenticação nativos.
  • Conceda permissões de API.
  • Crie um fluxo de usuário.
  • Associe o aplicativo ao fluxo do usuário.
• Um projeto android. Se você não tiver um projeto android, crie-o.

Adicionar dependências da MSAL

1. Abra seu projeto no Android Studio ou crie um novo projeto.

2. Abra o aplicativo build.gradle e adicione as seguintes dependências:

   allprojects {
       repositories {
           //Needed for com.microsoft.device.display:display-mask library
           maven {
               url 'https://pkgs.dev.azure.com/MicrosoftDeviceSDK/DuoSDK-Public/_packaging/Duo-SDK-Feed/maven/v1'
               name 'Duo-SDK-Feed'
           }
           mavenCentral()
           google()
       }
   }
   //...
   
   dependencies { 
       implementation 'com.microsoft.identity.client:msal:6.+'
       //...
   }
   

3. No Android Studio, selecione Arquivo>Sincronizar Projeto com Arquivos Gradle.

Criar um arquivo de configuração

Você passa os identificadores de locatário necessários, como a ID do aplicativo (cliente), para o SDK da MSAL por meio de uma configuração JSON.

Use estas etapas para criar o arquivo de configuração:

1. No painel de projetos do Android Studio, navegue até app\src\main\res.

2. Clique com o botão direito do mouse em res e selecione Novo>Diretório. Insira raw como o novo nome do diretório e selecione OK.

3. Em app\src\main\res\rawww, crie um novo arquivo JSON chamado auth_config_native_auth.json.

4. auth_config_native_auth.json No arquivo, adicione as seguintes configurações de MSAL:

   { 
     "client_id": "Enter_the_Application_Id_Here", 
     "authorities": [ 
       { 
         "type": "CIAM", 
         "authority_url": "https://Enter_the_Tenant_Subdomain_Here.ciamlogin.com/Enter_the_Tenant_Subdomain_Here.onmicrosoft.com/" 
       } 
     ], 
     "challenge_types": ["oob"], 
     "logging": { 
       "pii_enabled": false, 
       "log_level": "INFO", 
       "logcat_enabled": true 
     } 
   } 
    //...
   

5. Substitua os seguintes espaços reservados pelos valores de locatário obtidos no centro de administração do Microsoft Entra:

   • Substitua o espaço reservado Enter_the_Application_Id_Here pela ID do aplicativo (ID do cliente) do app que você registrou anteriormente.
   • Substitua Enter_the_Tenant_Subdomain_Here pelo subdomínio do diretório (locatário). Por exemplo, se o domínio primário do locatário for contoso.onmicrosoft.com, use contoso. Se você não tiver o nome do locatário, saiba como ler os detalhes do locatário.

   Os tipos de desafio são uma lista de valores, que o aplicativo usa para notificar o Microsoft Entra sobre o método de autenticação compatível.

   • Para fluxos de inscrição e entrada com senha de uso único por email, use ["oob"].
   • Para fluxos de inscrição e entrada com email e senha, use ["oob","password"].
   • Para redefinição de senha self-service (SSPR), use ["oob"].

   Saiba mais sobre os tipos de desafio.

Opcional: configuração de registro em log

Ative o registro em log na criação do aplicativo criando um retorno de chamada de registro em log, para que o SDK possa gerar logs.

import com.microsoft.identity.client.Logger

fun initialize(context: Context) {
        Logger.getInstance().setExternalLogger { tag, logLevel, message, containsPII ->
            Logs.append("$tag $logLevel $message")
        }
    }

Para configurar o registrador, você precisa adicionar uma seção no arquivo de configuração: auth_config_native_auth.json

    //...
   { 
     "logging": { 
       "pii_enabled": false, 
       "log_level": "INFO", 
       "logcat_enabled": true 
     } 
   } 
    //...

1. logcat_enabled: habilita a funcionalidade de registro em log da biblioteca.
2. pii_enabled: especifica se as mensagens que contêm dados pessoais ou dados organizacionais são registradas. Quando definido como false, os logs não contêm dados pessoais. Quando definido como true, os logs podem conter dados pessoais.
3. log_level: Use-o para decidir qual nível de registro em log deverá habilitar. O Android dá suporte aos seguintes níveis de log:
   1. ERRO
   2. AVISO
   3. INFORMAÇÃO
   4. PROLIXO

Para mais informações sobre o log do MSAL, consulte Log no MSAL para Android.

Criar uma instância do SDK do MSAL de autenticação nativa

No método onCreate(), crie uma instância MSAL para que o aplicativo possa executar a autenticação com seu locatário por meio da autenticação nativa. O createNativeAuthPublicClientApplication() método retorna uma instância chamada authClient. Passe o arquivo de configuração JSON que você criou anteriormente como um parâmetro.

    //...
    authClient = PublicClientApplication.createNativeAuthPublicClientApplication( 
        this, 
        R.raw.auth_config_native_auth 
    )
    //...

Seu código deve ser semelhante ao seguinte snippet:

    class MainActivity : AppCompatActivity() { 
        private lateinit var authClient: INativeAuthPublicClientApplication 
 
        override fun onCreate(savedInstanceState: Bundle?) { 
            super.onCreate(savedInstanceState) 
            setContentView(R.layout.activity_main) 
 
            authClient = PublicClientApplication.createNativeAuthPublicClientApplication( 
                this, 
                R.raw.auth_config_native_auth 
            ) 
            getAccountState() 
        } 
 
        private fun getAccountState() {
            CoroutineScope(Dispatchers.Main).launch {
                val accountResult = authClient.getCurrentAccount()
                when (accountResult) {
                    is GetAccountResult.AccountFound -> {
                        displaySignedInState(accountResult.resultValue)
                    }
                    is GetAccountResult.NoAccountFound -> {
                        displaySignedOutState()
                    }
                }
            }
        } 
 
        private fun displaySignedInState(accountResult: AccountState) { 
            val accountName = accountResult.getAccount().username 
            val textView: TextView = findViewById(R.id.accountText) 
            textView.text = "Cached account found: $accountName" 
        } 
 
        private fun displaySignedOutState() { 
            val textView: TextView = findViewById(R.id.accountText) 
            textView.text = "No cached account found" 
        } 
    } 

• Recupere a conta armazenada em cache usando o getCurrentAccount(), que retorna um objeto, accountResult.
• Se uma conta estiver em persistência, use GetAccountResult.AccountFound para exibir um estado conectado.
• Caso contrário, use GetAccountResult.NoAccountFound para exibir um estado desconectado.

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

Próxima etapa