Gerenciar objetos WebView

O Android fornece várias APIs para ajudar você a gerenciar os objetos WebView que exibem conteúdo da Web no seu app.

Esta página descreve como usar essas APIs para trabalhar com objetos WebView de maneira mais eficaz, melhorando a estabilidade e a segurança do app.

API Version

A partir do Android 7.0 (nível da API 24), os usuários podem escolher entre vários pacotes diferentes para exibir conteúdo da Web em um objeto WebView. A biblioteca Jetpack Webkit inclui o método getCurrentWebViewPackage() para buscar informações relacionadas ao pacote que está mostrando conteúdo da Web no seu app. Esse método é útil ao analisar erros que ocorrem somente quando o app tenta mostrar conteúdo da Web usando a implementação de um pacote específico de WebView.

Para usar esse método, adicione a lógica mostrada no snippet de código a seguir:

Kotlin

val webViewPackageInfo = WebViewCompat.getCurrentWebViewPackage(appContext)
Log.d("MY_APP_TAG", "WebView version: ${webViewPackageInfo.versionName}")

Java

PackageInfo webViewPackageInfo = WebViewCompat.getCurrentWebViewPackage(appContext);
Log.d("MY_APP_TAG", "WebView version: " + webViewPackageInfo.versionName);

Observação:o método getCurrentWebViewPackage() pode retornar null se o dispositivo estiver configurado incorretamente, não for compatível com o uso de WebView, como um dispositivo Wear OS, ou não tiver uma implementação WebView atualizável.

Serviço de Navegação segura do Google

Para oferecer uma experiência de navegação mais segura aos usuários, os objetos WebView verificam URLs usando a Navegação segura do Google, que permite que o app mostre um aviso aos usuários quando eles tentarem navegar para um site não seguro.

Embora o valor padrão de EnableSafeBrowsing seja verdadeiro, há casos em que você pode querer ativar a Navegação segura apenas condicionalmente ou desativá-la. O Android 8.0 (nível da API 26) e versões mais recentes são compatíveis com o uso de setSafeBrowsingEnabled() para ativar ou desativar a Navegação segura em um objeto WebView individual.

Se você quiser que todos os objetos WebView desativem as verificações do "Navegação segura", adicione o seguinte elemento <meta-data> ao arquivo de manifesto do app:

Observação:a recusa do manifesto de navegação segura não se aplica a WebView no SDK Runtime.

<manifest>
    <application>
        <meta-data android:name="android.webkit.WebView.EnableSafeBrowsing"
                   android:value="false" />
        ...
    </application>
</manifest>

Atenção:recomendamos manter a Navegação segura do Google ativada em todos os momentos e projetar seu app de acordo com as restrições causadas por ela.

Definir ações programáticas

Quando uma instância de WebView tenta carregar uma página que é classificada pelo Google como uma ameaça conhecida, a WebView mostra, por padrão, um intersticial que avisa os usuários sobre a ameaça. Essa tela dá aos usuários a opção de carregar o URL mesmo assim ou de retornar à página segura anterior.

Se você segmenta o Android 8.1 (nível da API 27) ou versões mais recentes, é possível definir de forma programática como o app responde a uma ameaça conhecida das seguintes maneiras:

• Você pode controlar se o app reporta as ameaças conhecidas para o "Navegação segura".
• Você pode fazer com que o app realize automaticamente uma ação específica, como voltar à segurança, sempre que encontrar um URL classificado como uma ameaça conhecida.

Observação:para conseguir a melhor proteção contra ameaças conhecidas, aguarde até inicializar o "Navegação segura" antes de invocar um método loadUrl() do objeto WebView.

Os snippets de código a seguir mostram como instruir as instâncias de WebView do app a sempre voltar à segurança depois de encontrar uma ameaça conhecida:

MyWebActivity.java

Kotlin

private lateinit var superSafeWebView: WebView
private var safeBrowsingIsInitialized: Boolean = false

// ...

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    superSafeWebView = WebView(this)
    superSafeWebView.webViewClient = MyWebViewClient()
    safeBrowsingIsInitialized = false

    if (WebViewFeature.isFeatureSupported(WebViewFeature.START_SAFE_BROWSING)) {
        WebViewCompat.startSafeBrowsing(this, ValueCallback<Boolean> { success ->
            safeBrowsingIsInitialized = true
            if (!success) {
                Log.e("MY_APP_TAG", "Unable to initialize Safe Browsing!")
            }
        })
    }
}

Java

private WebView superSafeWebView;
private boolean safeBrowsingIsInitialized;

// ...

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    superSafeWebView = new WebView(this);
    superSafeWebView.setWebViewClient(new MyWebViewClient());
    safeBrowsingIsInitialized = false;

    if (WebViewFeature.isFeatureSupported(WebViewFeature.START_SAFE_BROWSING)) {
        WebViewCompat.startSafeBrowsing(this, new ValueCallback<Boolean>() {
            @Override
            public void onReceiveValue(Boolean success) {
                safeBrowsingIsInitialized = true;
                if (!success) {
                    Log.e("MY_APP_TAG", "Unable to initialize Safe Browsing!");
                }
            }
        });
    }
}

MyWebViewClient.java

Kotlin

class MyWebViewClient : WebViewClientCompat() {
    // Automatically go "back to safety" when attempting to load a website that
    // Google identifies as a known threat. An instance of WebView calls this
    // method only after Safe Browsing is initialized, so there's no conditional
    // logic needed here.
    override fun onSafeBrowsingHit(
            view: WebView,
            request: WebResourceRequest,
            threatType: Int,
            callback: SafeBrowsingResponseCompat
    ) {
        // The "true" argument indicates that your app reports incidents like
        // this one to Safe Browsing.
        if (WebViewFeature.isFeatureSupported(WebViewFeature.SAFE_BROWSING_RESPONSE_BACK_TO_SAFETY)) {
            callback.backToSafety(true)
            Toast.makeText(view.context, "Unsafe web page blocked.", Toast.LENGTH_LONG).show()
        }
    }
}

Java

public class MyWebViewClient extends WebViewClientCompat {
    // Automatically go "back to safety" when attempting to load a website that
    // Google identifies as a known threat. An instance of WebView calls this
    // method only after Safe Browsing is initialized, so there's no conditional
    // logic needed here.
    @Override
    public void onSafeBrowsingHit(WebView view, WebResourceRequest request,
            int threatType, SafeBrowsingResponseCompat callback) {
        // The "true" argument indicates that your app reports incidents like
        // this one to Safe Browsing.
        if (WebViewFeature.isFeatureSupported(WebViewFeature.SAFE_BROWSING_RESPONSE_BACK_TO_SAFETY)) {
            callback.backToSafety(true);
            Toast.makeText(view.getContext(), "Unsafe web page blocked.",
                    Toast.LENGTH_LONG).show();
        }
    }
}

API HTML5 Geolocation

Para apps voltados ao Android 6.0 (nível da API 23) ou versões posteriores, a API Geolocation só é compatível com origens seguras, como o HTTPS. Qualquer solicitação para a API Geolocation em origens não seguras é automaticamente negada, sem invocar o método onGeolocationPermissionsShowPrompt() correspondente.

Desativar a coleta de métricas

A WebView consegue fazer upload de dados de diagnóstico anônimos para o Google diante do consentimento do usuário. Os dados são coletados em cada app para cada aplicativo que instanciar uma WebView. Você pode desativar esse recurso criando a seguinte tag no elemento <application> do manifesto:

<manifest>
    <application>
    ...
    <meta-data android:name="android.webkit.WebView.MetricsOptOut"
               android:value="true" />
    </application>
</manifest>

O upload dos dados só será feito a partir de um app se o usuário consentir e se o app não desativar a opção. Para mais informações sobre como desativar os relatórios de dados de diagnóstico, consulte Privacidade do usuário nos relatórios da WebView.

API Termination Handling

A API Termination Handling gerencia casos em que o processo do renderizador de um objeto WebView desaparece, seja porque o sistema interrompe o renderizador para reivindicar a memória necessária ou porque o processo do renderizador falha. Ao usar essa API, você permite que seu app continue em execução, mesmo que o processo do renderizador desapareça.

Atenção:se o app continuar em execução após o fim do processo do renderizador, a instância associada de WebView não poderá ser reutilizada, mesmo que o processo do renderizador seja interrompido ou falhe. Seu app precisa remover a instância da hierarquia de visualização e destruí-la para continuar a execução. Depois disso, o app precisa criar uma instância inteiramente nova de WebView para continuar processando páginas da Web.

Se um renderizador travar ao carregar uma determinada página da Web, tentar carregar a mesma página novamente poderá fazer com que um novo objeto WebView exiba o mesmo comportamento de falha de renderização.

O snippet de código a seguir ilustra como usar essa API em um Activity:

Kotlin

    
inner class MyRendererTrackingWebViewClient : WebViewClient() {
    private var mWebView: WebView? = null

    override fun onRenderProcessGone(view: WebView, detail: RenderProcessGoneDetail): Boolean {
        if (!detail.didCrash()) {
            // Renderer is killed because the system ran out of memory. The app
            // can recover gracefully by creating a new WebView instance in the
            // foreground.
            Log.e("MY_APP_TAG", ("System killed the WebView rendering process " +
                "to reclaim memory. Recreating..."))

            mWebView?.also { webView ->
                val webViewContainer: ViewGroup = findViewById(R.id.my_web_view_container)
                webViewContainer.removeView(webView)
                webView.destroy()
                mWebView = null
            }

            // By this point, the instance variable "mWebView" is guaranteed to
            // be null, so it's safe to reinitialize it.

            return true // The app continues executing.
        }

        // Renderer crashes because of an internal error, such as a memory
        // access violation.
        Log.e("MY_APP_TAG", "The WebView rendering process crashed!")

        // In this example, the app itself crashes after detecting that the
        // renderer crashed. If you handle the crash more gracefully and let
        // your app continue executing, you must destroy the current WebView
        // instance, specify logic for how the app continues executing, and
        // return "true" instead.
        return false
    }
}

Java

public class MyRendererTrackingWebViewClient extends WebViewClient {
    private WebView mWebView;

    @Override
    public boolean onRenderProcessGone(WebView view,
            RenderProcessGoneDetail detail) {
        if (!detail.didCrash()) {
            // Renderer is killed because the system ran out of memory. The app
            // can recover gracefully by creating a new WebView instance in the
            // foreground.
            Log.e("MY_APP_TAG", "System killed the WebView rendering process " +
                    "to reclaim memory. Recreating...");

            if (mWebView != null) {
                ViewGroup webViewContainer =
                        (ViewGroup) findViewById(R.id.my_web_view_container);
                webViewContainer.removeView(mWebView);
                mWebView.destroy();
                mWebView = null;
            }

            // By this point, the instance variable "mWebView" is guaranteed to
            // be null, so it's safe to reinitialize it.

            return true; // The app continues executing.
        }

        // Renderer crashes because of an internal error, such as a memory
        // access violation.
        Log.e("MY_APP_TAG", "The WebView rendering process crashed!");

        // In this example, the app itself crashes after detecting that the
        // renderer crashed. If you handle the crash more gracefully and let
        // your app continue executing, you must destroy the current WebView
        // instance, specify logic for how the app continues executing, and
        // return "true" instead.
        return false;
    }
}

API Renderer Importance

Quando os objetos WebView operam no modo multiprocesso, você tem alguma flexibilidade em como o app lida com situações de falta de memória. É possível usar a API Renderer Importance, introduzida no Android 8.0, para definir uma política de prioridade para o renderizador atribuído a um objeto WebView específico. Em particular, você pode querer que a parte principal do app continue em execução quando um renderizador que exibe os objetos WebView dele for eliminado. Isso pode ser feito, por exemplo, se você não espera mostrar o objeto WebView por muito tempo para que o sistema possa recuperar a memória que o renderizador estava usando.

O snippet de código a seguir mostra como atribuir uma prioridade ao processo do renderizador associado aos objetos WebView do app:

Kotlin

val myWebView: WebView = ...
myWebView.setRendererPriorityPolicy(RENDERER_PRIORITY_BOUND, true)

Java

WebView myWebView;
myWebView.setRendererPriorityPolicy(RENDERER_PRIORITY_BOUND, true);

Nesse snippet, a prioridade do renderizador é a mesma que a prioridade padrão do app ou está vinculada a ela. O argumento true diminui a prioridade do renderizador para RENDERER_PRIORITY_WAIVED quando o objeto WebView associado não está mais visível. Em outras palavras, um argumento true indica que, para o app, não faz diferença se o sistema mantém o processo do renderizador ativo. Esse nível de prioridade menor torna provável que o processo do renderizador seja interrompido em situações de falta de memória.

Aviso:para manter a estabilidade do app, não mude a política de prioridade do renderizador para um objeto WebView, a menos que você também use a API Termination Handling para especificar de que forma o WebView reage quando o renderizador associado desaparece.

Para saber mais sobre como o sistema gerencia situações de pouca memória, consulte Processos e ciclo de vida do app.