¿Cómo escuchar un WebView terminando de cargar una URL?

447

Tengo un WebViewque está cargando una página de Internet. Quiero mostrar un ProgressBarhasta que se complete la carga.

¿Cómo escucho la finalización de la carga de la página de a WebView?

Janusz
fuente
1
Considere marcar mi respuesta como correcta, ya que resuelve algunos problemas que ian no tiene.
neteinstein
Creo que es una mejor manera de llamar al código nativo de Java con js cuando se carga la página. Consulte esta respuesta, aunque es para ios, pero la idea también se aplica aquí .
Kris Roofe
Consulte mi respuesta a continuación para obtener una solución mínima y concisa
Skynet

Respuestas:

716

Extienda WebViewClient y llame a onPageFinished () de la siguiente manera:

mWebView.setWebViewClient(new WebViewClient() {

   public void onPageFinished(WebView view, String url) {
        // do your stuff here
    }
});
ian
fuente
Tengo algunos problemas con las cargas externas cuando Internet no es tan rápido. Por ejemplo, Google Analytics u otras cosas como esa. Intenté algunas soluciones y ha mejorado mucho, pero aún no es perfecto. A veces, la aplicación se congela en la pantalla de carga y es imposible salir, a menos que desconecte la red o se conecte a otra buena. Todavía no sé cómo resolver esto, lo estoy intentando.
Felipe
1
Funciona perfecto Puede usar mWebView.setVisibility (View.INVISIBLE) antes de cargar. Cuando se complete la carga, vuelva a configurar View.VISIBLE. Lo utilicé con esta pantalla de inicio
Johan Hoeksma
39
Esto no es una solución en absoluto. No hay garantía de que la página ya esté cargada cuando se llama a este método.
Hawk
3
Este es un diseño tan malo por parte de Google. Casi todo el tiempo, cuando se completa esta acción, desea hacer algo orientado a la Actividad principal, no a la vista web en sí. Anular una función en lugar de suscribirse a un evento es un antipatrón común y una razón por la que no me gusta el desarrollo de Android.
Ryan
66
Este método no garantiza el final de la carga y se puede llamar más de una vez si la carga de la URL requiere una navegación de URL intermedia. Entonces esto se llama varias veces. Sin embargo, es una forma de comprobarlo.
principiante el
150

@ian esto no es 100% exacto. Si tiene varios iframes en una página, tendrá múltiples onPageFinished (y onPageStarted). Y si tiene varias redirecciones, también puede fallar. Este enfoque resuelve (casi) todos los 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; 
        }
    }
});

ACTUALIZAR:

De acuerdo con la documentación: no se llamará a onPageStarted cuando cambie el contenido de un marco incrustado, es decir, al hacer clic en un enlace cuyo objetivo es un iframe.

Encontré un caso específico como ese en Twitter donde solo se llamó a pageFinished y la lógica se confundió un poco. Para resolver eso, agregué una tarea programada para eliminar la carga después de X segundos. Esto no es necesario en todos los demás casos.

ACTUALIZACIÓN 2 :

Ahora con la implementación actual de 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; 
            }
        }
    });
Neteinstein
fuente
3
Probablemente haya notado la advertencia en el documento de onPageStarted: onPageStarted NO se llamará cuando cambie el contenido de un marco incrustado, es decir, haga clic en un enlace cuyo objetivo es un iframe. Entonces esto puede sesgar la lógica en esos casos. Por cierto, ¿funciona realmente la simplificación de @polen?
an00b
1
Buena captura, nunca noté las cosas del marco. No he probado el código de polen ... lo único que puedo asegurar que funciona es lo anterior que estoy usando.
neteinstein
3
Solo una pequeña corrección. En realidad, es "public void onPageStarted (vista WebView, String url, Bitmap favicon)" en lugar de "public void onPageStarted (vista WebView, String url)"
MrMaffen
No funciona para algunos de los sitios más nuevos que nunca terminan de cargar ... por ejemplo, "agoda.com". Nunca recibe la llamada onPageFinished porque es una redirección.
kenyee
He visto en onPageFinished ser llamado dos veces durante una redirección. Pero lo que ha dicho "Si tiene varios iframes en una página tendrá múltiples onPageFinished (y onPageStarted)" no es correcto según la documentación de onPageFinished: "Este método se llama solo para el marco principal".
granate
40

Soy bastante parcial con la solución @NeTeInStEiN (y @polen) pero la hubiera implementado con un contador en lugar de múltiples booleanos o observadores de estado (solo otro sabor, pero pensé que podría compartir). Tiene un matiz JS al respecto, pero creo que la lógica es un poco más 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.
            }
        }
    });
}
SciSpear
fuente
2
Tu código se ve bien. He estado intentando lo mismo para mi webview que se carga desde datos html no url. Pero este activa el onPageFinished si la primera vista web se carga rápidamente y antes de que la segunda comience a cargarse. Escenario normal corriendo = 1, corriendo = 2, --running = 1, --running = 0. Escenario inusual que falla - corriendo = 1, - corriendo = 0, corriendo = 1 corriendo = 0
Ajith Memana
1
También hay otro escenario, cuando un evento no se dispara por alguna razón, nunca se alcanzará la parte TODO. Por lo tanto, necesita un temporizador para verificar los tiempos de espera. O puede llamar a una función java exportada en javascript cuando sepa que todo está cargado correctamente. Algo como documentReady () o algo así.
Codebeat
¿Por qué no solo running = 1;en onPageStarted()?
Choletski
@Choletski Porque el máximo de 1 y un número mayor que 1 no es 1.
Mateo leyó el
25

También encontré una solución elegante, aunque no la he probado rigurosamente:

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);
            }
        } 
Skynet
fuente
2
Lo probé y funciona perfectamente. Puede, por supuesto, llamarlo desde fuera del método onPageFinished y usar un controlador para verificar en intervalos cortos; en casos, no desea extender la clase WebViewClient.
Gal Rom el
1
Creo que esto podría ser mejor que la respuesta aceptada, solo tendrías que verificar onError y estás listo.
Evin1_
1
Esta debería ser la respuesta aceptada.
زياد
1
Votación a favor de este
Khdkls
23

He simplificado el código de NeTeInStEiN para que sea así:

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;
            }

        }
 });

Es fácil de entender, OnPageFinished si la devolución de llamada anterior está en onPageStarted, por lo que la página está completamente cargada.

polen
fuente
3
@polen PAGE_STARTED nunca se borra? ¿Qué pasa si nunca se llama a OverOverrideUrlLoading ()?
an00b
20

Si desea mostrar una barra de progreso, debe escuchar un evento de cambio de progreso, no solo para completar la página:

mWebView.setWebChromeClient(new WebChromeClient(){

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

                //change your progress bar
            }


        });

Por cierto, si desea mostrar solo una barra de progreso indeterminada, anular el método en PageFinished es suficiente

Francesco Laurita
fuente
5

Puede rastrear el estado de progreso mediante el método getProgress en la clase webview .

Inicializar el estado del progreso.

private int mProgressStatus = 0;

entonces la AsyncTask para cargar así:

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();
        }
    }
}
Praveen
fuente
mProgressStatus = webview.getProgress (); necesita ser llamado desde un hilo de la interfaz de usuario.
Skynet
5

Gracias por las respuestas. Me ayudó, pero tuve que mejorarlo un poco para mis necesidades. Tuve varios inicios de página y acabados, así que agregué un temporizador que verifica si al finalizar el inicio de página se inicia un nuevo inicio de página. De acuerdo, mala explicación. Ver el 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);
            }
        }

});
EscapeNetscape
fuente
2

Aquí hay un método novedoso para detectar cuando una URL se ha cargado utilizando la capacidad de Android para enlaces de JavaScript . Usando este patrón, explotamos el conocimiento de JavaScript del estado del documento para generar una llamada a un método nativo dentro del tiempo de ejecución de Android. Estas llamadas accesibles a JavaScript se pueden hacer usando la @JavaScriptInterfaceanotación.

Esta implementación requiere que recurramos setJavaScriptEnabled(true)a la WebViewconfiguración de 's, por lo que podría no ser adecuada dependiendo de los requisitos de su aplicación, por ejemplo, problemas de seguridad.

src / io / github / cawfree / webviewcallback / MainActivity.java (Jelly Bean, API Nivel 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"
/>

Esencialmente, estamos agregando una función JavaScript adicional que se utiliza para probar el estado del documento. Si está cargado, lanzamos una costumbreonPageLoaded() evento en Android MainActivity; de lo contrario, registramos un detector de eventos que actualiza Android una vez que la página está lista, usando window.addEventListener('onload', ...);.

Dado que estamos agregando este script después de que this.getWebView().loadURL("")se haya realizado la llamada a , es probable que no necesitemos 'escuchar' los eventos en absoluto, ya que solo tenemos la oportunidad de agregar el enlace de JavaScript haciendo una llamada sucesiva a loadURL, una vez que la página ya se ha cargado.

Mapsy
fuente
Impresionante solución, que generalmente funciona. Tengo problemas con https://reddit.com/r/Nature (con Reddit en general), cuando hace clic en algún hilo y el hilo está cargado, no puedo atrapar ese evento. ¿Me puedes ayudar?
Primož Kralj
@ PrimožKralj Me alegra saber que está teniendo cierto éxito con esto ... No estoy seguro de qué sugerir específicamente, pero si hay algún tipo de evento público que sepa que se desencadena, puede conectarse, por ejemplo, cuando el recuento de comentarios se actualiza, puede usarlo como fuente. ¿Ha considerado que tal vez su problema podría solucionarse presionando directamente la API de Reddit ?
Mapsy
1
Gracias, echaré otro vistazo a los eventos activados e intentaré conectarme a uno de ellos. Soy consciente de la API e intentaré implementar una solución más robusta para usarla en el futuro. ¡Gracias!
Primož Kralj
1

Solo para mostrar la barra de progreso, los métodos "onPageStarted" y "onPageFinished" son suficientes; pero si desea tener un indicador "is_loading" (junto con redireccionamientos de página, ...), estos métodos pueden ejecutarse sin secuenciación, como "onPageStarted> onPageStarted> onPageFinished> onPageFinished".

Pero con mi breve prueba (pruébelo usted mismo), la cola de valores del método "onProgressChanged" es "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);
    }
}

También establezca " is_loading = false" al cerrar la actividad, si es una variable estática porque la actividad se puede finalizar antes de que finalice la página.

Jalil Hamdollahi Oskouei
fuente
0

Cargando url con SwipeRefreshLayouty 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>
Hamid
fuente
0

Aquí hay un método que le permite registrar un archivo Runnablepara que se ejecute una vez que una dirección web en particular haya terminado de cargarse. Asociamos cada uno Runnablecon una URL correspondiente Stringen a Map, y utilizamos el método WebView's getOriginalUrl()para elegir la devolución de llamada apropiada.

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;
    }

}
Mapsy
fuente
0

El procesador no finalizará la representación cuando se llame al método OnPageFinshed o el progreso alcance el 100%, por lo que ambos métodos no le garantizan que la vista se haya procesado por completo.

Pero puede averiguar, a partir del método OnLoadResource, lo que ya se ha procesado y lo que todavía se está procesando. Y este método se llama varias veces.

        @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.

            }
        }
shreedhar
fuente
0

Use esto, debería ayudar .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.
}

// También debe anular otro método de anulación de error como onReceiveError para ver cómo se llaman todos estos métodos uno tras otro y cómo se comportan mientras se depura con punto de interrupción. } `

Alguien
fuente
-1

para usuarios de Kotlin:

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

aunque hay muchos métodos que puedes anular

Amin Keshavarzian
fuente