Como ouvir um WebView terminar de carregar um URL?


447

Eu tenho um WebViewque está carregando uma página da Internet. Quero mostrar um ProgressBaraté que o carregamento esteja completo.

Como escuto a conclusão do carregamento da página de um WebView?


1
Por favor, considere marcar minha resposta como correta, pois resolve alguns problemas que aian não resolve.
Neteinstein

Eu acho que uma maneira melhor de chamar o código java nativo com js quando a página é carregada. Consulte esta resposta, embora seja para ios, mas a ideia também se aplica aqui .
Kris Roofe

Confira abaixo a minha resposta para a solução mínima e concisa
Skynet

Respostas:


715

Estenda o WebViewClient e chame onPageFinished () da seguinte maneira:

mWebView.setWebViewClient(new WebViewClient() {

   public void onPageFinished(WebView view, String url) {
        // do your stuff here
    }
});

Tenho alguns problemas com carregamentos externos quando a Internet não é tão rápida. Por exemplo, o Google Analytics ou outras coisas assim. Eu tentei algumas soluções alternativas e melhorou muito, mas ainda não é perfeito. Às vezes, o aplicativo congela na tela de carregamento e é impossível sair, a menos que você desconecte a rede ou conecte-se a outra boa. Ainda não sei como resolver isso, estou tentando.
Felipe

1
Funciona perfeito. Você pode usar o mWebView.setVisibility (View.INVISIBLE) antes de carregar. Quando o carregamento estiver concluído, volte para View.VISIBLE. Usei-o com este tela inicial: android-developers.blogspot.de/2009/03/...
Johan Hoeksma

39
Esta não é uma solução. Não há garantia de que a página já esteja carregada quando esse método for chamado.
Hawk

3
Esse é um design tão ruim da parte do Google. Quase todo o tempo em que essa ação é concluída, você deseja fazer algo orientado em torno da Atividade pai, não da própria visualização da Web. Substituir uma função em vez de se inscrever em um evento é um anti-padrão comum e o motivo pelo qual eu não gosto do desenvolvimento do Android.
28916 Ryan

6
Esse método não garante o término da carga e pode ser chamado mais de uma vez se a carga da URL exigir alguma navegação intermediária. Portanto, isso é chamado várias vezes. No entanto, é uma maneira de verificar isso.
iniciante

150

@ian isso não é 100% exato. Se você tiver vários iframes em uma página, terá vários onPageFinished (e onPageStarted). E se você tiver vários redirecionamentos, também poderá falhar. Essa abordagem resolve (quase) todos os problemas:

boolean loadingFinished = true;
boolean redirect = false;

mWebView.setWebViewClient(new WebViewClient() {

    @Override
    public boolean shouldOverrideUrlLoading(WebView view, String urlNewString) {
        if (!loadingFinished) {
            redirect = true;
        }

        loadingFinished = false;
        webView.loadUrl(urlNewString);
        return true;
    }

    @Override
    public void onPageStarted(WebView view, String url) {
        loadingFinished = false;
        //SHOW LOADING IF IT ISNT ALREADY VISIBLE  
    }

    @Override
    public void onPageFinished(WebView view, String url) {
        if (!redirect) {
           loadingFinished = true;
            //HIDE LOADING IT HAS FINISHED
        } else {
            redirect = false; 
        }
    }
});

ATUALIZAR:

De acordo com a documentação: onPageStarted NÃO será chamado quando o conteúdo de um quadro incorporado for alterado, ou seja, clicar em um link cujo destino seja um iframe.

Encontrei um caso específico como esse no Twitter em que apenas uma página Finalizada foi chamada e mexeu um pouco na lógica. Para resolver isso, adicionei uma tarefa agendada para remover o carregamento após X segundos. Isso não é necessário em todos os outros casos.

ATUALIZAÇÃO 2 :

Agora, com a implementação atual do Android WebView:

boolean loadingFinished = true;
boolean redirect = false;

    mWebView.setWebViewClient(new WebViewClient() {

        @Override
        public boolean shouldOverrideUrlLoading(
                WebView view, WebResourceRequest request) {
            if (!loadingFinished) {
               redirect = true;
            }

            loadingFinished = false;
            webView.loadUrl(request.getUrl().toString());
            return true;
        }

        @Override
        public void onPageStarted(
                WebView view, String url, Bitmap favicon) {
            super.onPageStarted(view, url, favicon);
            loadingFinished = false;
            //SHOW LOADING IF IT ISNT ALREADY VISIBLE  
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            if (!redirect) {
               loadingFinished = true;
                //HIDE LOADING IT HAS FINISHED
            } else {
                redirect = false; 
            }
        }
    });

3
Você provavelmente notou a ressalva no documento do onPageStarted: onPageStarted NÃO será chamado quando o conteúdo de um quadro incorporado for alterado, ou seja, clicar em um link cujo destino seja um iframe. Portanto, isso pode distorcer a lógica nesses casos. BTW, a simplificação do @ polen realmente funciona?
An00b

1
Boa captura, nunca notei o material da moldura. Eu não tentei o código do polen .. o único que eu posso garantir que o trabalho é o acima que eu estou usando.
Neteinstein

3
Apenas uma pequena correção. É realmente "vazio onPageStarted (vista WebView, String url, favicon Bitmap) pública" em vez de "vazio onPageStarted público (vista WebView, String url)"
MrMaffen

Não funciona em alguns sites mais recentes que nunca terminam de carregar ... por exemplo, "agoda.com". Você nunca recebe a chamada onPageFinished porque é um redirecionamento.
Kenyee

Já vi onPageFinished ser chamado duas vezes durante um redirecionamento. Porém, o que você disse "Se você tiver vários iframes em uma página, terá vários onPageFinished (e onPageStarted)" não está correto conforme a documentação do onPageFinished: "Esse método é chamado apenas para o quadro principal".
granada

40

Sou bastante parcial com a solução @NeTeInStEiN (e @polen), mas a teria implementado com um contador em vez de vários booleanos ou observadores de estado (apenas outro sabor, mas achei que poderia compartilhar). Ele tem uma nuance de JS, mas acho que a lógica é um pouco mais fácil de entender.

private void setupWebViewClient() {
    webView.setWebViewClient(new WebViewClient() {
        private int running = 0; // Could be public if you want a timer to check.

        @Override
        public boolean shouldOverrideUrlLoading(WebView webView, String urlNewString) {
            running++;
            webView.loadUrl(urlNewString);
            return true;
        }

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            running = Math.max(running, 1); // First request move it to 1.
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            if(--running == 0) { // just "running--;" if you add a timer.
                // TODO: finished... if you want to fire a method.
            }
        }
    });
}

2
Seu código parece bom. Eu tenho tentado o mesmo para o meu webview que carrega a partir de dados html não url. Mas este aciona o onPageFinished se a primeira visualização na web carregar rapidamente e antes que a segunda comece a carregar. Cenário normal. running = 1, running = 2, --running = 1, --running = 0. Cenário incomum que não - correndo = 1, --running = 0, correndo = 1 running = 0
Ajith Memana

1
Também existe outro cenário, quando um evento não é acionado por algum motivo, a parte TODO nunca será alcançada. Então, você precisa de um cronômetro para verificar o tempo limite. Ou você pode chamar uma função java exportada em javascript quando souber que tudo está carregado corretamente. Algo como documentReady () ou algo assim.
Codebeat

por que não apenas running = 1;entrar onPageStarted()?
Choletski 14/07/19

@ Coletski Porque o máximo de 1 e um número maior que 1 não é 1. #:
Matthew Leia

25

Também encontrei uma solução elegante, mas não a testei rigorosamente:

public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
            if (m_webView.getProgress() == 100) {
                progressBar.setVisibility(View.GONE);
                m_webView.setVisibility(View.VISIBLE);
            }
        } 

2
Eu testei e está funcionando perfeitamente. É claro que você pode chamá-lo de fora do método onPageFinished e usar um Handler para verificar em intervalos curtos - em casos, você não deseja estender a classe WebViewClient.
Gal Rom

1
Acredito que isso possa ser melhor do que a resposta aceita, você só precisa verificar o onError e está pronto.
Evin1_

1
Essa deve ser a resposta aceita.
زياد


23

Eu simplifiquei o código do NeTeInStEiN para ficar assim:

mWebView.setWebViewClient(new WebViewClient() {
        private int       webViewPreviousState;
        private final int PAGE_STARTED    = 0x1;
        private final int PAGE_REDIRECTED = 0x2;

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String urlNewString) {
            webViewPreviousState = PAGE_REDIRECTED;
            mWebView.loadUrl(urlNewString);
            return true;
        }

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            super.onPageStarted(view, url, favicon);
            webViewPreviousState = PAGE_STARTED;
            if (dialog == null || !dialog.isShowing())
                dialog = ProgressDialog.show(WebViewActivity.this, "", getString(R.string.loadingMessege), true, true,
                        new OnCancelListener() {

                            @Override
                            public void onCancel(DialogInterface dialog) {
                                // do something
                            }
                        });
        }

        @Override
        public void onPageFinished(WebView view, String url) {

            if (webViewPreviousState == PAGE_STARTED) {
                dialog.dismiss();
                dialog = null;
            }

        }
 });

É fácil entender, OnPageFinished se o retorno de chamada anterior estiver em onPageStarted, para que a página seja completamente carregada.


3
@ Polen_STARTED nunca é limpo? E se shouldOverrideUrlLoading () nunca for chamado?
An00b

20

Se você deseja mostrar uma barra de progresso, precisa ouvir um evento de mudança de progresso, não apenas para a conclusão da página:

mWebView.setWebChromeClient(new WebChromeClient(){

            @Override
            public void onProgressChanged(WebView view, int newProgress) {

                //change your progress bar
            }


        });

BTW, se você deseja exibir apenas uma ProgressBar Indeterminada, substituindo o método onPageFinished, é suficiente



5

Você pode rastrear o Progress Staus pelo método getProgress em webview classe .

Inicialize o status do progresso

private int mProgressStatus = 0;

então o AsyncTask para carregar assim:

private class Task_News_ArticleView extends AsyncTask<Void, Void, Void> {
    private final ProgressDialog dialog = new ProgressDialog(
            your_class.this);

    // can use UI thread here
    protected void onPreExecute() {
        this.dialog.setMessage("Loading...");
        this.dialog.setCancelable(false);
        this.dialog.show();
    }

    @Override
    protected Void doInBackground(Void... params) {
        try {
            while (mProgressStatus < 100) {
                mProgressStatus = webview.getProgress();

            }
        } catch (Exception e) {

        }
        return null;

    }

    protected void onPostExecute(Void result) {
        if (this.dialog.isShowing()) {
            this.dialog.dismiss();
        }
    }
}

mProgressStatus = webview.getProgress (); precisa ser chamado de um thread da interface do usuário.
Skynet

5

obrigado pelas respostas. Isso me ajudou, mas tive que melhorar um pouco para as minhas necessidades. Como eu tinha várias pagestarts e acabamentos, adicionei um timer que verifica se após o início da página é iniciado um novo pagestart. Ok, explicação ruim. Veja o código :)

myWebView.setWebViewClient(new WebViewClient() {
        boolean loadingFinished = true;
        boolean redirect = false;

        long last_page_start;
        long now;

        // Load the url
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            if (!loadingFinished) {
                redirect = true;
            }

            loadingFinished = false;
            view.loadUrl(url);
            return false;
        }

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            Log.i("p","pagestart");
            loadingFinished = false;
            last_page_start = System.nanoTime();
            show_splash();
        }

        // When finish loading page
        public void onPageFinished(WebView view, String url) {
            Log.i("p","pagefinish");
            if(!redirect){
                loadingFinished = true;
            }
            //call remove_splash in 500 miSec
            if(loadingFinished && !redirect){
                now = System.nanoTime();
                new android.os.Handler().postDelayed(
                        new Runnable() {
                            public void run() {
                                remove_splash();
                            }
                        },
                        500);
            } else{
                redirect = false;
            }
        }
        private void show_splash() {
            if(myWebView.getVisibility() == View.VISIBLE) {
                myWebView.setVisibility(View.GONE);
                myWebView_splash.setVisibility(View.VISIBLE);
            }
        }
        //if a new "page start" was fired dont remove splash screen
        private void remove_splash() {
            if (last_page_start < now) {
                myWebView.setVisibility(View.VISIBLE);
                myWebView_splash.setVisibility(View.GONE);
            }
        }

});

2

Aqui está um novo método para detectar quando um URL é carregado utilizando a capacidade do Android para ganchos de JavaScript . Usando esse padrão, exploramos o conhecimento do JavaScript sobre o estado do documento para gerar uma chamada de método nativa no tempo de execução do Android. Essas chamadas acessíveis por JavaScript podem ser feitas usando a @JavaScriptInterfaceanotação.

Essa implementação requer que solicitemos setJavaScriptEnabled(true)as WebViewconfigurações do sistema, portanto, pode não ser adequado, dependendo dos requisitos do seu aplicativo, por exemplo, preocupações de segurança.

src / io / github / cawfree / webviewcallback / MainActivity.java (Jelly Bean, API nível 16)

package io.github.cawfree.webviewcallback;

/**
 *  Created by Alex Thomas (@Cawfree), 30/03/2017.
 **/

import android.net.http.SslError;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.webkit.JavascriptInterface;
import android.webkit.SslErrorHandler;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.Toast;

/** An Activity demonstrating how to introduce a callback mechanism into Android's WebView. */
public class MainActivity extends AppCompatActivity {

    /* Static Declarations. */
    private static final String HOOK_JS             = "Android";
    private static final String URL_TEST            = "http://www.zonal.co.uk/";
    private static final String URL_PREPARE_WEBVIEW = "";

    /* Member Variables. */
    private WebView mWebView = null;

    /** Create the Activity. */
    @Override protected final void onCreate(final Bundle pSavedInstanceState) {
        // Initialize the parent definition.
        super.onCreate(pSavedInstanceState);
        // Set the Content View.
        this.setContentView(R.layout.activity_main);
        // Fetch the WebView.
        this.mWebView = (WebView)this.findViewById(R.id.webView);
        // Enable JavaScript.
        this.getWebView().getSettings().setJavaScriptEnabled(true);
        // Define the custom WebClient. (Here I'm just suppressing security errors, since older Android devices struggle with TLS.)
        this.getWebView().setWebViewClient(new WebViewClient() { @Override     public final void onReceivedSslError(final WebView pWebView, final SslErrorHandler pSslErrorHandler, final SslError pSslError) { pSslErrorHandler.proceed(); } });
        // Define the WebView JavaScript hook.
        this.getWebView().addJavascriptInterface(this, MainActivity.HOOK_JS);
        // Make this initial call to prepare JavaScript execution.
        this.getWebView().loadUrl(MainActivity.URL_PREPARE_WEBVIEW);
    }

    /** When the Activity is Resumed. */
    @Override protected final void onPostResume() {
        // Handle as usual.
        super.onPostResume();
        // Load the URL as usual.
        this.getWebView().loadUrl(MainActivity.URL_TEST);
        // Use JavaScript to embed a hook to Android's MainActivity. (The onExportPageLoaded() function implements the callback, whilst we add some tests for the state of the WebPage so as to infer when to export the event.)
        this.getWebView().loadUrl("javascript:" + "function onExportPageLoaded() { " + MainActivity.HOOK_JS + ".onPageLoaded(); }" + "if(document.readyState === 'complete') { onExportPageLoaded(); } else { window.addEventListener('onload', function () { onExportPageLoaded(); }, false); }");
    }

    /** Javascript-accessible callback for declaring when a page has loaded. */
    @JavascriptInterface @SuppressWarnings("unused") public final void onPageLoaded() {
        // Display the Message.
        Toast.makeText(this, "Page has loaded!", Toast.LENGTH_SHORT).show();
    }

    /* Getters. */
    public final WebView getWebView() {
        return this.mWebView;
    }

}

res / layout / activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<WebView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/webView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
/>

Basicamente, anexamos uma função JavaScript adicional usada para testar o estado do documento. Se estiver carregado, lançamos um onPageLoaded()evento personalizado no Android MainActivity; caso contrário, registramos um ouvinte de evento que atualiza o Android quando a página estiver pronta, usando window.addEventListener('onload', ...);.

Como anexamos esse script depois que a chamada this.getWebView().loadURL("")foi feita, é provável que não precisemos 'ouvir' os eventos, pois só temos a chance de anexar o gancho JavaScript, fazendo uma chamada sucessiva para loadURL, uma vez que a página já foi carregada.


Solução impressionante, que geralmente funciona. Estou tendo problemas com https://reddit.com/r/Nature (geralmente no Reddit), quando você clica em algum tópico e o tópico está carregado, não consigo capturar esse evento. Você pode me ajudar?
Primož Kralj

@ PrimožKralj Fico feliz em saber que você está tendo algum sucesso com isso ... Não tenho certeza do que sugerir especificamente, mas se houver algum tipo de evento público que você sabe que é acionado, você pode participar, por exemplo, quando o a contagem de comentários é atualizada, você pode usá-la como fonte. Você já pensou que talvez seu problema pudesse ser resolvido pressionando a API do Reddit diretamente?
Mapsy

1
Obrigado, darei outra olhada nos eventos acionados e tentarei me conectar a um deles. Estou ciente da API e tentarei implementar uma solução mais robusta usando-a no futuro. Obrigado!
Primož Kralj

1

Apenas para mostrar a barra de progresso, os métodos "onPageStarted" e "onPageFinished" são suficientes; mas se você deseja ter um sinalizador "is_loading" (junto com os redirecionamentos de página, ...), esses métodos podem ser executados sem sequenciamento, como a fila "onPageStarted> onPageStarted> onPageFinished> onPageFinished".

Mas com o meu teste curto (teste você mesmo.), A fila de valores do método "onProgressChanged" é "0-100> 0-100> 0-100> ..."

private boolean is_loading = false;

webView.setWebChromeClient(new MyWebChromeClient(context));

private final class MyWebChromeClient extends WebChromeClient{
    @Override
    public void onProgressChanged(WebView view, int newProgress) {
        if (newProgress == 0){
            is_loading = true;
        } else if (newProgress == 100){
            is_loading = false;
        }
        super.onProgressChanged(view, newProgress);
    }
}

Defina também " is_loading = false" no fechamento da atividade, se for uma variável estática, porque a atividade pode ser concluída antes do término da página.


0

Carregando URL com SwipeRefreshLayoute ProgressBar:

UrlPageActivity.java:

    WebView webView;
    SwipeRefreshLayout _swipe_procesbar;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_url_page);


        String url = "http://stackoverflow.com/";

        _swipe_procesbar = (SwipeRefreshLayout)findViewById(R.id.url_path_swipe_procesbar);

        _swipe_procesbar.post(new Runnable() {
                                  @Override
                                  public void run() {
                                      _swipe_procesbar.setRefreshing(true);
                                  }
                              }
        );

        webView = (WebView) findViewById(R.id.url_page_web_view);
        webView.getSettings().setJavaScriptEnabled(true);

        webView.setWebViewClient(new WebViewClient() {
            public void onPageFinished(WebView view, String url) {
                _swipe_procesbar.setRefreshing(false);
                _swipe_procesbar.setEnabled(false);
            }
        });
        webView.loadUrl(url);
    }

activity_url_page.xml:

<android.support.v4.widget.SwipeRefreshLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/url_path_swipe_procesbar"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">
        <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
            xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
            android:layout_height="match_parent"
            tools:context="com.test.test1.UrlPageActivity">


            <WebView
                android:layout_width="fill_parent"
                android:layout_height="fill_parent"
                android:id="@+id/url_page_web_view" />
        </RelativeLayout>

</android.support.v4.widget.SwipeRefreshLayout>

0

Aqui está um método que permite que você registre um Runnablea ser executado assim que um determinado endereço da Web terminar de carregar. Associamos cada Runnableum a uma URL correspondente Stringem a Mape usamos o método WebView's getOriginalUrl()para escolher o retorno de chamada apropriado.

package io.github.cawfree.webviewcallback;

/**
 *  Created by Alex Thomas (@Cawfree), 30/03/2017.
 **/

import android.net.http.SslError;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.webkit.SslErrorHandler;
import android.webkit.WebView;
import android.webkit.WebViewClient;

import java.util.HashMap;
import java.util.Map;

/** An Activity demonstrating how to introduce a callback mechanism into Android's WebView. */
public class MainActivity extends AppCompatActivity {

    /* Member Variables. */
    private WebView               mWebView;
    private Map<String, Runnable> mCallbackMap;

    /** Create the Activity. */
    @Override protected final void onCreate(final Bundle pSavedInstanceState) {
        // Initialize the parent definition.
        super.onCreate(pSavedInstanceState);
        // Set the Content View.
        this.setContentView(R.layout.activity_main);
        // Fetch the WebView.
        this.mWebView     = (WebView)this.findViewById(R.id.webView);
        this.mCallbackMap = new HashMap<>();
        // Define the custom WebClient. (Here I'm just suppressing security errors, since older Android devices struggle with TLS.)
        this.getWebView().setWebViewClient(new WebViewClient() {
            /** Handle when a request has been launched. */
            @Override public final void onPageFinished(final WebView pWebView, final String pUrl) {
                // Determine whether we're allowed to process the Runnable; if the page hadn't been redirected, or if we've finished redirection.
                if(pUrl.equals(pWebView.getOriginalUrl())) {
                    // Fetch the Runnable for the OriginalUrl.
                    final Runnable lRunnable = getCallbackMap().get(pWebView.getOriginalUrl());
                    // Is it valid?
                    if(lRunnable != null) { lRunnable.run(); }
                }
                // Handle as usual.
                super.onPageFinished(pWebView, pUrl);
            }
            /** Ensure we handle SSL state properly. */
            @Override public final void onReceivedSslError(final WebView pWebView, final SslErrorHandler pSslErrorHandler, final SslError pSslError) { pSslErrorHandler.proceed(); }
        });
        // Assert that we wish to visit Zonal's website.
        this.getWebView().loadUrl("http://www.zonal.co.uk/");
        // Align a Callback for Zonal; this will be serviced once the page has loaded.
        this.getCallbackMap().put("http://www.zonal.co.uk/", new Runnable() {     @Override public void run() { /* Do something. */ } });
    }

    /* Getters. */
    public final WebView getWebView() {
        return this.mWebView;
    }

    private final Map<String, Runnable> getCallbackMap() {
        return this.mCallbackMap;
    }

}

0

O renderizador não concluirá a renderização quando o método OnPageFinshed for chamado ou o progresso atingir 100%, para que ambos os métodos não garantam que a exibição tenha sido renderizada completamente.

Mas você pode descobrir pelo método OnLoadResource o que já foi renderizado e o que ainda está sendo renderizado. E esse método é chamado várias vezes.

        @Override
        public void onLoadResource(WebView view, String url) {
            super.onLoadResource(view, url);
           // Log and see all the urls and know exactly what is being rendered and visible. If you wanna know when the entire page is completely rendered, find the last url from log and check it with if clause and implement your logic there.
            if (url.contains("assets/loginpage/img/ui/forms/")) {
                // loginpage is rendered and visible now.
               // your logic here.

            }
        }

0

Use isso para ajudar. Var currentUrl = "google.com" var partOfUrl = currentUrl.substring (0, currentUrl.length-2)

webView.setWebViewClient (objeto: WebViewClient () {

override fun onLoadResource(WebView view, String url) {
     //call loadUrl() method  here 
     // also check if url contains partOfUrl, if not load it differently.
     if(url.contains(partOfUrl, true)) {
         //it should work if you reach inside this if scope.
     } else if(!(currentUrl.startWith("w", true))) {
         webView.loadurl("www.$currentUrl")

     } else if(!(currentUrl.startWith("h", true))) {
         webView.loadurl("https://$currentUrl")

     } else { ...}


 }

override fun onReceivedSslError(view: WebView?, handler: SslErrorHandler?, error: SslError?) {
   // you can call again loadUrl from here too if there is any error.
}

// Você também deve substituir outro método de substituição como erro, como onReceiveError, para ver como todos esses métodos são chamados um após o outro e como eles se comportam durante a depuração com ponto de interrupção. } `


-1

para usuários do Kotlin:

webView.webViewClient = object : WebViewClient() {
            override fun onPageFinished(view: WebView?, url: String?) {
                // do your logic
            }
        }

existem muitos métodos que você pode substituir

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.