Contente
- Adicione a biblioteca biométrica
- Adicione a permissão USE_BIOMETRIC
- Crie o layout do seu aplicativo
- Autenticando a identidade do usuário
- Crie uma instância de prompt biométrico
- Manipular os retornos de chamada de autenticação
- 1. onAuthenticationSucceeded ()
- 2. onAuthenticationFailed ()
- 3. onAuthenticationError
- 4. onAuthenticationHelp
- Implementando a autenticação biométrica do Android Pie
- Testando seu projeto
- Empacotando
Vamos usar a API BiometricPrompt para criar um aplicativo que permita ao usuário confirmar sua identidade usando uma impressão digital.
Abra o Android Studio e crie um novo projeto, usando o modelo "Atividade vazia". Quando solicitado, defina o SDK mínimo do seu projeto para 28 ou superior, pois isso impedirá que seu aplicativo seja instalado em algo anterior ao Android Pie.
Se você deseja tornar seu aplicativo acessível a uma variedade maior de dispositivos Android, verifique em qual versão do Android seu aplicativo está atualmente instalado e lide com a autenticação biométrica de maneira diferente, dependendo do nível de API do dispositivo.
Adicione a biblioteca biométrica
Para começar, abra o arquivo build.gradle no nível do módulo e inclua a versão mais recente da biblioteca Biometric como uma dependência do projeto:
dependências {implementação androidx.biometric: biometric: 1.0.0-alpha03
Adicione a permissão USE_BIOMETRIC
A API BiometricPrompt permite explorar todos os diferentes métodos de autenticação biométrica suportados pelo dispositivo, por meio de uma única permissão.
Abra o manifesto do seu projeto e adicione a permissão "USE_BIOMETRIC":
Crie o layout do seu aplicativo
Em seguida, vamos criar o layout do nosso aplicativo. Vou adicionar um único botão que, quando tocado, abrirá a caixa de diálogo de autenticação de impressão digital:
Abra o arquivo strings.xml do seu projeto e adicione o recurso de string "auth":
Autenticando a identidade do usuário
Agora, vamos ver como você autentica a identidade do usuário, usando BiometricPrompt.
Crie uma instância de prompt biométrico
A classe BiometricPrompt inclui uma classe Builder () complementar, que você pode usar para criar uma instância BiometricPrompt e iniciar a autenticação:
final BiometricPrompt.PromptInfo promptInfo = new BiometricPrompt.PromptInfo.Builder ()
Ao criar sua instância BiometricPrompt, você precisará definir o texto que deve aparecer na caixa de diálogo de autenticação e personalizar o "botão negativo", que é o botão que permite ao usuário cancelar a autenticação.
Para configurar a caixa de diálogo de autenticação, é necessário fornecer o seguinte:
- setTitle. O título do prompt de autenticação de impressão digital. (Requeridos)
- setSubtitle. A legenda do prompt de autenticação de impressão digital. (Opcional)
- setDescription. Uma descrição adicional que será exibida na sua caixa de diálogo de autenticação. (Opcional)
- setNegativeButton (texto, executor, ouvinte). Esse é o rótulo do botão negativo, por exemplo, "Cancelar" ou "Sair". Ao configurar o botão negativo, você também precisará fornecer uma instância do Executor e um OnClickListener para que o usuário possa descartar a caixa de diálogo de autenticação.
No momento da redação, não era possível personalizar o ícone ou o erro usado na caixa de diálogo de autenticação.
Por fim, você precisará chamar build (). Isso nos dá o seguinte:
final BiometricPrompt.PromptInfo promptInfo = new BiometricPrompt.PromptInfo.Builder () .setTitle ("O texto do título aparece aqui") .setSubtitle ("A legenda aparece aqui") .setDescription ("Esta é a descrição") .setNegativeButtonText ("Cancelar") .construir();
Manipular os retornos de chamada de autenticação
A instância BiometricPrompt recebeu um conjunto de métodos de retorno de chamada de autenticação que notificarão seu aplicativo sobre os resultados do processo de autenticação.
Você precisará agrupar todos esses retornos de chamada em uma instância da classe BiometricPrompt.AuthenticationCallback:
final BiometricPrompt myBiometricPrompt = new BiometricPrompt (activity, newExecutor, new BiometricPrompt.AuthenticationCallback () {
A próxima etapa é implementar alguns ou todos os seguintes métodos de retorno de chamada:
1. onAuthenticationSucceeded ()
Esse método é chamado quando a impressão digital é correspondida com êxito a uma das impressões digitais registradas no dispositivo. Nesse cenário, um objeto AuthenticationResult é passado para o retorno de chamada onAuthenticationSucceeded e seu aplicativo executará uma tarefa em resposta a essa autenticação bem-sucedida.
Para ajudar a simplificar, nosso aplicativo responderá imprimindo um no Logcat do Android Studio:
@Override public void onAuthenticationSucceeded (resultado @NonNull BiometricPrompt.AuthenticationResult) {super.onAuthenticationSucceeded (resultado); Log.d (TAG, "Impressão digital reconhecida com sucesso"); }
2. onAuthenticationFailed ()
Esse método é acionado quando a digitalização é concluída com êxito, mas a impressão digital não corresponde a nenhuma das impressões registradas no dispositivo. Novamente, nosso aplicativo responderá a esse evento de autenticação, imprimindo um no Logcat:
@ Substituir public void onAuthenticationFailed () {super.onAuthenticationFailed (); Log.d (TAG, "Impressão digital não reconhecida"); }
3. onAuthenticationError
Esse retorno de chamada é acionado sempre que ocorre um erro irrecuperável e a autenticação não pode ser concluída com êxito. Por exemplo, talvez o sensor de toque do dispositivo esteja coberto de sujeira ou graxa, o usuário não registrou nenhuma impressão digital neste dispositivo ou não há memória suficiente disponível para realizar uma varredura biométrica completa.
Aqui está o código que vou usar no meu aplicativo:
@Override public void onAuthenticationError (int errorCode, @NonNull CharSequence errString) {super.onAuthenticationError (errorCode, errString); if (errorCode == BiometricPrompt.ERROR_NEGATIVE_BUTTON) {} else {Log.d (TAG, "Ocorreu um erro irrecuperável"); }}
4. onAuthenticationHelp
O método onAuthenticationHelp é chamado sempre que ocorre um erro não fatal e inclui um código de ajuda e um que fornecem informações adicionais sobre o erro.
Para ajudar a manter nosso código simples, não usarei onAuthenticationHelp em nosso aplicativo, mas uma implementação seria mais ou menos assim:
@Override public void onAuthenticationHelp (int helpCode, CharSequence helpString) {super.onAuthenticationHelp (helpCode, helpString); biometricCallback.onAuthenticationHelp (helpCode, helpString); }
Por fim, precisamos chamar o método authenticate () da instância BiometricPrompt:
myBiometricPrompt.authenticate (promptInfo);
Implementando a autenticação biométrica do Android Pie
Depois de concluir todas as etapas acima, sua MainActivity deve ficar assim:
importar androidx.appcompat.app.AppCompatActivity; importar androidx.biometric.BiometricPrompt; importar android.os.Bundle; importar java.util.concurrent.Executor; importar java.util.concurrent.Executors; importar androidx.fragment.app.FragmentActivity; importar android.util.Log; importar android.view.View; import androidx.annotation.NonNull; classe pública MainActivity estende AppCompatActivity {final estático privado String TAG = MainActivity.class.getName (); @Override void protegido onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); // Crie um pool de threads com um único thread // Executor newExecutor = Executors.newSingleThreadExecutor (); Atividade FragmentActivity = this; // Comece a escutar eventos de autenticação // final BiometricPrompt myBiometricPrompt = new BiometricPrompt (activity, newExecutor, new BiometricPrompt.AuthenticationCallback () {@Override // onAuthenticationError é chamado quando ocorre um erro fatal // public void onAuthenticationError (int errorCode, @NonNull CharSequence errString) {super.onAuthenticationError (errorCode, errString); if (errorCode == BiometricPrompt.ERROR_NEGATIVE_BUTTON) {} else {// Imprima no Logcat // Log.d (TAG, "Ocorreu um erro irrecuperável");}} // onAuthenticationSucceeded é chamado quando uma impressão digital é correspondida com êxito // @Override public void onAuthenticationSucceeded (resultado de @NonNull BiometricPrompt.AuthenticationResult) {super.onAuthenticationSucceeded (resultado); // Imprime um no Logcat // Log.d (TAG, "Impressão digital reconhecido com sucesso ");} // onAuthenticationFailed é chamado quando a impressão digital não corresponde a // @Override public void onAuthenticationFailed () {super.onAuthenticationFailed (); // Imprima um para o log cat // Log.d (TAG, "Impressão digital não reconhecida"); }}); // Crie a instância BiometricPrompt // final BiometricPrompt.PromptInfo promptInfo = new BiometricPrompt.PromptInfo.Builder () // Adicione um pouco de texto à caixa de diálogo // .setTitle ("O texto do título entra aqui") .setSubtitle ("A legenda aqui" ) .setDescription ("Esta é a descrição") .setNegativeButtonText ("Cancelar") // Constrói a caixa de diálogo // .build (); // Atribua um onClickListener ao botão "Autenticação" do aplicativo // findViewById (R.id.launchAuthentication) .setOnClickListener (novo View.OnClickListener () {@Override public void onClick (View v) {myBiometricPrompt.authenticate (promptInfo);} }); }}
Testando seu projeto
Agora que você criou seu projeto, é hora de testá-lo e ver se ele realmente adiciona autenticação de impressão digital ao seu aplicativo!
Para executar este projeto, você precisará de um smartphone ou tablet físico que esteja executando o Android Pie ou um dispositivo virtual Android (AVD) que esteja usando a visualização do Android P ou superior.
Você também precisará registrar pelo menos uma impressão digital no seu dispositivo. Se você estiver usando um dispositivo Android físico, então:
- Proteja sua tela de bloqueio com um PIN, senha ou padrão, se você ainda não o fez (navegando para "Configurações> Tela de bloqueio e segurança> Tipo de bloqueio de tela> Padrão / PIN / Senha" e depois seguindo as instruções na tela).
- Inicie o aplicativo "Configurações" do seu dispositivo.
- Selecione "Tela de bloqueio e segurança".
- Selecione "Scanner de impressão digital".
- Siga as instruções para registrar uma ou mais impressões digitais.
Os dispositivos virtuais Android não possuem um sensor de toque físico, portanto, você precisa simular um evento de toque:
- Inicie o seu AVD, se você ainda não o fez.
- Ao lado do AVD, você verá uma faixa de botões. Encontre o botão "Mais" com três pontos (onde o cursor está posicionado na captura de tela a seguir) e clique nele. Isso inicia a janela "Controles estendidos".
- Na janela Controles estendidos, selecione “Impressão digital”. Isso abre um conjunto de controles, onde você pode emular vários eventos de toque.
- Abra o menu suspenso e escolha a impressão digital que deseja registrar neste dispositivo; Estou usando o "dedo 1".
- Agora, vamos voltar nossa atenção para o dispositivo emulado. Inicie o aplicativo "Configurações" do AVD e selecione "Segurança e localização".
- Se você ainda não configurou um PIN, senha ou padrão, selecione "Bloqueio de tela" e siga as instruções na tela para proteger sua tela de bloqueio. Em seguida, volte para a tela principal "Configurações> Segurança e localização".
- Selecione "Impressão digital", seguido de "Adicionar impressão digital".
- Agora, você será solicitado a pressionar o dedo no sensor de toque. Em vez disso, continue clicando em "Toque no sensor" até ver uma "Impressão digital adicionada".
- Clique em "Concluído".
- Se você deseja registrar impressões digitais adicionais, enxágue e repita as etapas acima.
Depois de registrar pelo menos uma impressão digital, você estará pronto para testar seu aplicativo. Vou testar como nosso aplicativo lida com três cenários diferentes:
- O usuário tenta se autenticar usando uma impressão digital registrada.
- O usuário tenta se autenticar usando uma impressão digital que não está registrada neste dispositivo.
- O usuário tenta se autenticar usando impressões digitais não registradas, várias vezes e em rápida sucessão.
Vamos tentar autenticar usando a impressão digital que acabamos de registrar em nosso dispositivo:
- Verifique se está visualizando o Logcat Monitor do Android Studio, pois é aqui que os vários s do seu aplicativo serão exibidos.
- Instale seu aplicativo no dispositivo de teste.
- Toque no botão "Autenticar com impressão digital" do seu aplicativo. A caixa de diálogo de autenticação de impressão digital será exibida.
- Se você estiver usando um dispositivo físico, pressione e segure a ponta do dedo contra o sensor de toque do dispositivo. Se você estiver usando um AVD, use o botão "Toque no sensor" para simular um evento de toque.
- Verifique o Logcat Monitor. Se a autenticação foi bem-sucedida, você deve ver o seguinte: “Impressão digital reconhecida com sucesso”
A seguir, vamos ver o que acontece se tentarmos autenticar usando uma impressão digital que não está registrada neste dispositivo:
- Toque no botão "Autenticar com impressão digital" do aplicativo novamente.
- Se você estiver usando um AVD, use a janela "Controles estendidos" para selecionar uma impressão digital que não é registrado neste dispositivo; Estou usando o "Dedo 2". Dê um clique no botão "Toque no sensor".
- Se você estiver usando um smartphone ou tablet Android físico, pressione e segure a ponta do dedo contra o sensor de toque do dispositivo - verifique se está usando um dedo que não está registrado neste dispositivo!
- Verifique o Logcat do Android Studio, agora ele deve exibir uma "Impressão digital não reconhecida".
Como já mencionado, a API BiometricPrompt lida automaticamente com tentativas excessivas de autenticação com falha. Para testar esta funcionalidade:
- Toque no botão "Autenticar com impressão digital" do seu aplicativo.
- Tente autenticar várias vezes em rápida sucessão, usando uma impressão digital não registrada.
- Após algumas tentativas, a caixa de diálogo deve fechar automaticamente. Verifique o Logcat do Android Studio e você verá o seguinte: "Ocorreu um erro irrecuperável".
Você pode baixar o aplicativo completo no GitHub.
Empacotando
Neste artigo, exploramos a nova API BiometricPrompt do Android Pie, que permite adicionar facilmente autenticação de impressão digital ao seu aplicativo. Você acha que o BiometricPrompt é uma melhoria nos métodos de autenticação de impressões digitais anteriores do Android? Deixe-nos saber nos comentários abaixo!
