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.

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 avaliarJavascript() 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 onPageFinished() 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 AutofillManager.requestAutofill() é executado quando os campos de entrada estão em foco, permitindo que o gerenciador de senhas recomende credenciais salvas. Nós utilizamos setOnFocusChangeListener() 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 está habilitado() 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 solicitaçãoAutofill(), são chamados ao lidar com os campos de entrada do WebView. Usando Mockito.verify(), 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.