Solução de problemas de preenchimento automático de senha no Android Webview

Compreendendo o desaparecimento repentino das sugestões de preenchimento automático

Se o seu aplicativo Android incluir uma página de login da web em um webview, você poderá usar o gerenciador de senhas do sistema para oferecer credenciais salvas. Normalmente, quando o usuário acessa a caixa de texto de login, o nome de usuário ou endereço de e-mail aparece na parte superior do teclado.

No entanto, se você percebeu recentemente que essas ideias deixaram de aparecer, isso pode ser muito frustrante. Isso é especialmente verdadeiro se não houver alterações no código do seu aplicativo ou nas configurações do gerenciador de senhas.

Essa mudança inesperada pode ser o resultado de uma atualização do sistema Android que altera o funcionamento das sugestões de senha nas visualizações da web. Também é possível que o problema seja devido a uma configuração no nível do sistema.

Muitos desenvolvedores agora estão se perguntando se outros estão enfrentando o mesmo problema e que esforços podem ser feitos para resolvê-lo. Este artigo investigará as possíveis origens e soluções para o problema.

Comando	Exemplo de uso
evaluateJavascript()	Este comando injeta e executa código JavaScript em um WebView. É necessário para alterar componentes na página incorporada, como focar em campos de entrada para gerar recomendações de preenchimento automático.
AutofillManager.requestAutofill()	Essa técnica solicita especificamente que o sistema Android Autofill solicite sugestões de nome de usuário/senha salvas para uma determinada visualização, mesmo que o sistema não faça isso automaticamente.
setOnFocusChangeListener()	Anexa um ouvinte ao WebView para detectar quando um campo de entrada está em foco, permitindo-nos ativar ações programaticamente, como o preenchimento automático, quando o foco muda.
getSystemService()	Esse método obtém serviços no nível do sistema, como o AutofillManager, necessário para usar os recursos de preenchimento automático do Android.
WebView.setWebViewClient()	Permite personalizar o comportamento do WebView ao carregar conteúdo. Nessa situação, garante que o código JavaScript específico seja executado assim que a página terminar de carregar.
isEnabled()	Usado para determinar se o serviço Android Autofill está ativado no dispositivo. Esta é uma etapa importante antes de tentar usar qualquer recurso de preenchimento automático de forma programática.
onPageFinished()	Este método WebViewClient é chamado quando o WebView termina de carregar uma página, permitindo injetar JavaScript e interagir com o DOM.
Mockito.verify()	No contexto de testes unitários, este comando determina se um método específico (como requestAutofill()) foi chamado em um objeto simulado, garantindo que o código funcione conforme o esperado.

Noções básicas sobre soluções para problemas de preenchimento automático do WebView

O primeiro script resolve o problema injetando JavaScript no WebView e acionando manualmente o serviço Android Autofill. Quando você clica na caixa de texto de login, o O método concentra-se nos campos de entrada, como as caixas de nome de usuário e senha. Essa ênfase manual permite que o sistema Android identifique o campo de entrada e use as credenciais salvas anteriormente. O método garante que o JavaScript seja executado somente após o carregamento completo da página. Este script fornece uma solução simples para quaisquer possíveis problemas causados ​​pela falta de contato entre o WebView e o sistema Android.

O segundo método envolve o uso da API AutofillManager para solicitar o preenchimento automático diretamente. Esta é uma abordagem mais integrada porque funciona diretamente com o sistema de preenchimento automático nativo do Android. A instrução é executado quando os campos de entrada estão em foco, permitindo que o gerenciador de senhas recomende credenciais salvas. Nós utilizamos para garantir que esta solicitação seja feita apenas quando o campo apropriado estiver em foco. Esta solução é útil para garantir a compatibilidade com diferentes versões e dispositivos Android porque não depende de JavaScript externo para iniciar o serviço de preenchimento automático.

A etapa final da solução é usar a API AutofillManager método para ver se o serviço Android Autofill está habilitado no dispositivo. Essa verificação é crítica antes de executar qualquer comando adicional para solicitar o preenchimento automático, pois impede que o programa tente usar um recurso desabilitado. Esta forma de validação melhora a robustez da solução e garante que o aplicativo funcione de forma eficaz em resposta às configurações do sistema.

Por fim, são criados testes unitários utilizando o framework Mockito para validar ambas as soluções. Esses testes garantem que os métodos necessários, como , são chamados ao lidar com os campos de entrada do WebView. Usando , podemos garantir que a injeção de JavaScript e a integração do AutofillManager funcionem conforme planejado. O teste unitário dessas interações garante que as soluções operem em vários dispositivos e versões do Android, fornecendo uma solução confiável para o problema de preenchimento automático em ambientes WebView.

// Inject JavaScript to interact with the WebView input fields
webView.setWebViewClient(new WebViewClient() {
   @Override
   public void onPageFinished(WebView view, String url) {
       // Injecting JavaScript to focus on the username input
       webView.evaluateJavascript("document.getElementById('username').focus();", null);
       // Trigger the password manager to display suggestions
       webView.evaluateJavascript("document.getElementById('password').focus();", null);
   }
});
// Enable JavaScript in WebView if not already enabled
webView.getSettings().setJavaScriptEnabled(true);

// Use the AutofillManager API to request autofill suggestions manually
AutofillManager autofillManager = (AutofillManager) getSystemService(Context.AUTOFILL_SERVICE);
// Check if Autofill is supported on the device
if (autofillManager != null && autofillManager.isEnabled()) {
   // Request autofill when the username field is focused
   webView.setOnFocusChangeListener((view, hasFocus) -> {
       if (hasFocus) {
           autofillManager.requestAutofill(view);
       }
   });
}

@Test
public void testJavaScriptAutofillTrigger() {
   // Mock WebView and AutofillManager behavior
   WebView webView = Mockito.mock(WebView.class);
   AutofillManager autofillManager = Mockito.mock(AutofillManager.class);
   webView.evaluateJavascript("document.getElementById('username').focus();", null);
   Mockito.verify(autofillManager).requestAutofill(webView);
}
@Test
public void testAutofillManagerIntegration() {
   // Validate the AutofillManager interaction with focused views
   View mockView = Mockito.mock(View.class);
   AutofillManager autofillManager = Mockito.mock(AutofillManager.class);
   autofillManager.requestAutofill(mockView);
   Mockito.verify(autofillManager).requestAutofill(mockView);

Explorando o comportamento do serviço de preenchimento automático do Android no WebView

Compreender como funciona o Android Autofill Service é crucial para solucionar problemas de preenchimento automático no Android WebView. Este serviço tem como objetivo facilitar aos usuários a inserção de credenciais salvas em diversos aplicativos, incluindo formulários de login na web. No entanto, a funcionalidade do WebView pode ser irregular. Isso ocorre porque, diferentemente das visualizações nativas do Android, o WebView executa conteúdo baseado na web, tornando as interações com serviços do sistema, como o preenchimento automático, menos previsíveis.

Um dos principais motivos pelos quais o preenchimento automático pode parar de funcionar inesperadamente é devido a alterações no componente WebView subjacente, que é atualizado rotineiramente como parte do aplicativo WebView do sistema Android. Essas modificações podem alterar a forma como os campos de entrada em um WebView interagem com o gerenciador de senhas, resultando em problemas semelhantes aos descritos. A atualização do componente WebView é fundamental para garantir a compatibilidade com os recursos e correções de bugs mais recentes do Android.

Outra causa possível pode ser as configurações de segurança no WebView. As versões modernas do Android priorizam a privacidade do usuário e a segurança dos dados. Se o WebView estiver configurado para restringir o acesso aos dados do formulário ou se o JavaScript estiver desativado, as recomendações de preenchimento automático poderão não ser exibidas. Os desenvolvedores devem otimizar as configurações do WebView, ativar o JavaScript e evitar tratar os formulários como conteúdo inseguro.

1. Por que minhas sugestões de preenchimento automático pararam de funcionar no WebView?
2. Esse problema pode ser causado por uma atualização do componente WebView do sistema Android ou por alterações nas configurações de segurança que afetam os dados do formulário no WebView.
3. Como posso ativar o preenchimento automático para WebView?
4. Use o API para ativar manualmente o preenchimento automático para campos de entrada. Para usar sugestões de preenchimento automático, verifique se as configurações do WebView permitem a execução de JavaScript.
5. Existe um método para verificar se meu dispositivo suporta preenchimento automático?
6. Sim, você pode usar o técnica para verificar se o preenchimento automático está ativado no dispositivo antes de solicitar sugestões de preenchimento automático.
7. O que devo fazer se os campos de nome de usuário ou senha não acionarem o preenchimento automático?
8. No WebView, você pode usar injeção de JavaScript para se concentrar manualmente nos campos de entrada executando , que destaca o campo do formulário.
9. As atualizações do sistema podem afetar o comportamento de preenchimento automático do WebView?
10. Sim, as atualizações do sistema, especialmente aquelas que afetam o componente WebView, podem alterar a forma como ele interage com os serviços de preenchimento automático. Mantenha sempre o WebView do Sistema Android atualizado.

Por fim, as dificuldades de preenchimento automático com o WebView podem ser causadas por diversas circunstâncias, como atualizações do sistema Android ou alterações nas configurações do WebView. Abordá-los envolve um exame completo da configuração do WebView e das permissões no nível do sistema.

Para restaurar a funcionalidade ausente, atualize , habilite o JavaScript e use APIs como . Usando essas estratégias, os desenvolvedores podem garantir que os consumidores tenham uma experiência de login tranquila e contínua.