Visualização da web do Android lenta

Os meus android webviewssão lentos. Isso 3.0+inclui tudo, desde telefones a tablets com especificações mais que adequadas

Eu sei que webviews é suposto ser "limitado" mas vejo Web Apps feito com gap de telefone que devem estar usando todos os tipos de CSS3e JQueryfeitiçaria, eles correm muito bem e rápida

então estou perdendo alguma coisa, existe algum tipo de coisa myWebview.SPEEDHACK(1)que eu possa usar para acelerar as coisas?

além disso, às vezes o conteúdo da minha visualização na web simplesmente não carrega, em vez de carregar lentamente, ele simplesmente não carrega. O ativo com o qual estou testando é armazenado localmente, sem erros.

Depende do aplicativo da web que está sendo carregado. Experimente algumas das abordagens abaixo:

Defina uma prioridade de renderização mais alta (descontinuada da API 18+):

webview.getSettings().setRenderPriority(RenderPriority.HIGH);

Ativar / desativar a aceleração de hardware:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    // chromium, enable hardware acceleration
    webView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
} else {
    // older android version, disable hardware acceleration
    webView.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
}

Desative o cache (se você tiver problemas com o seu conteúdo):

webview.getSettings().setCacheMode(WebSettings.LOAD_NO_CACHE);

Acrescentar isso android:hardwareAccelerated="true"no manifesto foi a única coisa que melhorou significativamente o desempenho para mim

Mais informações aqui: http://developer.android.com/guide/topics/manifest/application-element.html#hwaccel

A solução para nós foi o oposto. Desabilitamos a aceleração de hardware apenas no WebView (em vez de no aplicativo inteiro no manifesto) usando este código:

if (Build.VERSION.SDK_INT >= 11){
    webview.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
}

As animações CSS3 são mais suaves agora. Estamos usando o Android 4.0.

Mais informações aqui: https://code.google.com/p/android/issues/detail?id=17352

Eu acho que o seguinte funciona melhor:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    webView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
} else {
    webView.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
}

O Android 19 tem mecanismo Chromium para WebView. Eu acho que funciona melhor com aceleração de hardware.

Eu estava tendo esse mesmo problema e tive que resolvê-lo. Tentei essas soluções, mas no final o desempenho, pelo menos para a rolagem, não melhorou nada. Então aqui está a solução alternativa que eu realizei e a explicação de por que funcionou para mim.

Se você teve a chance de explorar os eventos de arrasto, criando um pouco da classe "MiWebView", substituindo o método "onTouchEvent" e imprimindo pelo menos a hora em que cada evento de arrasto ocorre, você verá que eles estão separados a tempo de (até) 9ms de distância. Esse é um período muito curto entre os eventos.

Veja o código-fonte do WebView e veja a função onTouchEvent. É simplesmente impossível que ele seja manuseado pelo processador em menos de 9ms (continue sonhando !!!). É por isso que você vê constantemente a mensagem "Não se preocupe, pois estamos aguardando a resposta do WebCore para o toque". mensagem. O código simplesmente não pode ser tratado a tempo.

Como corrigi-lo? Primeiro, você não pode reescrever o código onTouchEvent para melhorá-lo, é demais. Mas você pode "zombar" para limitar a taxa de eventos para movimentos de arrasto, digamos 40ms ou 50ms. (isso depende do processador).

Todos os eventos de toque são assim: ACTION_DOWN -> ACTION_MOVE ...... ACTION_MOVE -> ACTION_UP. Portanto, precisamos manter os movimentos DOWN e UP e filtrar a taxa de MOVE (esses são os bandidos).

E aqui está uma maneira de fazer isso (você pode adicionar mais tipos de eventos, como o toque de 2 dedos, tudo o que me interessa aqui é a rolagem com um dedo).

import android.content.Context;
import android.view.MotionEvent;
import android.webkit.WebView;


public class MyWebView extends WebView{

    public MyWebView(Context context) {
        super(context);
        // TODO Auto-generated constructor stub
    }

    private long lastMoveEventTime = -1;
    private int eventTimeInterval = 40;

    @Override
    public boolean onTouchEvent(MotionEvent ev) {

        long eventTime = ev.getEventTime();
        int action = ev.getAction();

        switch (action){
            case MotionEvent.ACTION_MOVE: {
                if ((eventTime - lastMoveEventTime) > eventTimeInterval){
                    lastMoveEventTime = eventTime;
                    return super.onTouchEvent(ev);
                }
                break;
            }
            case MotionEvent.ACTION_DOWN:
            case MotionEvent.ACTION_UP: {
                return super.onTouchEvent(ev);
            }
        }
        return true;
    }
}

É claro que use esta classe em vez do WebView e você verá a diferença ao rolar.

Esta é apenas uma abordagem para uma solução, mas ainda não totalmente implementada para todos os casos de atraso devido ao toque na tela ao usar o WebView. No entanto, é a melhor solução que encontrei, pelo menos para minhas necessidades específicas.

Tentei todas as propostas para corrigir o problema de desempenho de renderização no meu aplicativo phonegap. Mas nada realmente funcionou.

Finalmente, depois de um dia inteiro de busca, consegui. Defino na tag (não na tag) do meu AndroidManifest

<application android:hardwareAccelerated="false" ...

Agora, o aplicativo se comporta da mesma maneira rápida que o meu navegador da web. Parece que, se a aceleração do hardware nem sempre é o melhor recurso ...

O problema detalhado que tive: https://stackoverflow.com/a/24467920/3595386

Nenhuma dessas respostas não foi útil para mim.

Finalmente encontrei razão e solução. O motivo foi muitos filtros CSS3 (filtro, -webkit-filter).

Solução

Eu adicionei a detecção do WebView no script da página da web para adicionar a classe "baixa qualidade" ao corpo do HTML. Entre. Você pode acompanhar facilmente o WebView definindo user-agent nas configurações do WebView. Então eu criei uma nova regra CSS

body.lowquality * { filter: none !important; }

Se houver apenas alguns componentes do seu webview lentos ou atrasados, tente adicionar isso aos elementos css:

transform: translate3d(0,0,0);
-webkit-transform: translate3d(0,0,0);

Este foi o único speedhack que realmente afetou minha visualização na web. Mas tome cuidado para não usá-lo demais! (você pode ler mais sobre o hack neste artigo .)

Tente o seguinte:

mWebView.setLayerType(View.LAYER_TYPE_HARDWARE, null);

Se você está vinculando ao onclickevento, pode ser lento nas telas sensíveis ao toque.

Para torná-lo mais rápido, eu uso o fastclick , que usa os eventos de toque muito mais rápidos para imitar o evento de clique.