Comment écouter pour une WebView fin du chargement d'une URL?

@ian ce n'est pas précis à 100%. Si vous avez plusieurs iframe dans une page, vous aurez de multiples onPageFinished (et onPageStarted). Et si vous avez plusieurs redirige il peut également échouer. Cette approche résout (presque) tous les problèmes:

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

Mise à JOUR:

Selon la documentation:
onPageStarted ne sera PAS appelé lorsque le contenu d'un cadre incorporé les modifications, c'est à dire en cliquant sur un lien dont la cible est un iframe.

J'ai trouvé un cas spécifique comme ça sur Twitter, où seule une pageFinished a été appelé et a sali la logique un peu. Pour le résoudre j'ai ajouté une tâche planifiée pour supprimer le chargement après X secondes. Ce n'est pas nécessaire dans tous les autres cas.

Mise à JOUR 2:

Maintenant avec Android WebView mise en œuvre:

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

J'ai simplifié NeTeInStEiNle code comme cela:

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

        }
 });

Il est facile à comprendre, OnPageFinished si le rappel est sur onPageStarted, de sorte que la page soit complètement chargée.

J'en ai trouvé une solution élégante ainsi, ne l'ai pas testé rigoureusement bien:

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

Vous pouvez suivre les Progrès Staus par le getProgress méthode dans webview classe.

Initialiser l'état d'avancement

private int mProgressStatus = 0;

puis l'AsyncTask pour le chargement comme ceci:

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

Voici une nouvelle méthode pour détectée lorsqu'une URL est chargé par l'utilisation de Android capacité du JavaScript crochets. L'utilisation de ce modèle, nous exploitons JavaScript connaissance de l'état du document à générer un natif de l'appel de méthode à l'intérieur de l'Android runtime. Ces JavaScript accessible les appels peuvent être effectués à l'aide de la @JavaScriptInterface annotation.

Cette mise en œuvre exige que nous appelons setJavaScriptEnabled(true) sur le WebView's paramètres, de sorte qu'il pourrait ne pas être approprié selon les exigences de votre application, par exemple, les préoccupations de sécurité.

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

Essentiellement, nous sommes en ajoutant un supplément de fonction JavaScript qui est utilisé pour tester l'état du document. Si elle est chargée, nous avons lancé une coutume onPageLoaded() événement dans Android MainActivity; sinon, nous enregistrer un écouteur d'événement que les mises à jour Android une fois que la page est prête, à l'aide de window.addEventListener('onload', ...);.

Puisque nous sommes ajoutant ce script après l'appel à this.getWebView().loadURL("") a été faite, il est probable que nous n'avons pas besoin de ' "écouter" pour les événements de tous, puisque nous obtenez seulement une chance d'ajouter le JavaScript crochet en faisant un appel successif à loadURL, une fois que la page a déjà été chargé.

Voici une méthode qui vous permet de vous inscrire à un Runnable à être exécutée une fois un site web particulier de l'adresse de chargement est terminé. Nous associons à chaque Runnable avec une URL correspondant à String dans un Map, et nous utilisons la WebView's getOriginalUrl() méthode pour choisir le rappel.

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

pour Kotlin utilisateurs:

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

il ya beaucoup de méthodes que vous pouvez remplacer si