URL लोड करने वाले WebView परिष्करण के लिए कैसे सुनें?


447

मेरे पास WebViewइंटरनेट से एक पेज लोड हो रहा है । मैं ProgressBarलोडिंग पूरी होने तक दिखाना चाहता हूं ।

मैं पृष्ठ लोडिंग के पूरा होने के लिए कैसे सुनूं WebView?


1
कृपया मेरे उत्तर को सही मानने पर विचार करें, क्योंकि यह कुछ समस्याओं को हल करता है जो कि इयान की नहीं है।
neteinstein

मुझे लगता है कि पेज लोड होने पर जेएस के साथ देशी जावा कोड को कॉल करने का एक बेहतर तरीका है। इस उत्तर को देखें, हालांकि यह आईओएस के लिए है, लेकिन यह विचार यहां भी लागू होता है
क्राइस्ट रूफ

न्यूनतम और संक्षिप्त समाधान के लिए नीचे मेरे जवाब की जाँच करें
स्काईनेट

जवाबों:


716

WebViewClient बढ़ाएँ और onPageFinished () को निम्नानुसार कॉल करें :

mWebView.setWebViewClient(new WebViewClient() {

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

बाहरी लोडिंग के साथ मेरे कुछ मुद्दे हैं जब इंटरनेट इतनी तेजी से नहीं है। उदाहरण के लिए Google Analytics या उसके जैसे अन्य सामान। मैंने कुछ वर्कअराउंड की कोशिश की और इसमें बहुत सुधार हुआ है, लेकिन अभी तक सही नहीं है। कभी-कभी ऐप लोडिंग स्क्रीन पर फ्रीज हो जाता है और बाहर निकलना असंभव है, जब तक कि आप नेटवर्क को डिस्कनेक्ट न करें या किसी अन्य अच्छे में कनेक्ट न करें। मुझे नहीं पता कि इसे कैसे हल करना है, मैं कोशिश कर रहा हूं।
फेलिप

1
सही काम करता है। लोड करने से पहले आप mWebView.setVisibility (View.INVISIBLE) का उपयोग कर सकते हैं। जब लोड पूरा हो जाता है तो इसे वापस View.VISIBLE पर सेट करें। मैंने इसे इस स्प्लैश स्क्रीन के साथ प्रयोग किया: android-developers.blogspot.de/2009/03/…
जोहान होक्समा

39
यह बिल्कुल समाधान नहीं है। कोई गारंटी नहीं है कि इस पद्धति को कॉल करने पर पृष्ठ पहले से लोड है।
हॉक

3
यह Google की ओर से ऐसा खराब डिज़ाइन है। लगभग हर समय जब यह क्रिया पूरी हो जाती है तो आप मूल गतिविधि के आसपास कुछ उन्मुख करना चाहते हैं, न कि स्वयं वेब दृश्य। एक घटना की सदस्यता लेने के बजाय एक समारोह को ओवरराइड करना एक सामान्य विरोधी पैटर्न और कारण है जो मुझे एंड्रॉइड विकास को नापसंद करता है।
रयान

6
यह विधि लोड फ़िनिश की गारंटी नहीं देती है और एक बार से अधिक कॉल किया जा सकता है यदि url लोड कुछ मध्यवर्ती url नेविगेशन लेता है। इसलिए इसे कई बार कहा जाता है। हालाँकि इसकी जाँच करने का एक तरीका है।
शुरुआत

150

@ यह 100% सटीक नहीं है। यदि आपके पास एक पृष्ठ में कई iframes हैं, तो आपके पास कई onPageFinished (और onPageStarted) होंगे। और अगर आपके पास कई रीडायरेक्ट हैं तो यह विफल भी हो सकता है। यह दृष्टिकोण सभी समस्याओं को हल करता है:

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

अपडेट करें:

दस्तावेज़ीकरण के अनुसार: onPageStarted तब नहीं कहा जाएगा जब एक एम्बेडेड फ़्रेम की सामग्री बदल जाती है, अर्थात एक लिंक पर क्लिक करना जिसका लक्ष्य एक iframe है।

मुझे ट्विटर पर इस तरह का एक विशिष्ट मामला मिला जहां केवल एक पेजफिनिश किया गया था और तर्क को थोड़ा गड़बड़ कर दिया था। यह हल करने के लिए कि मैंने X सेकंड के बाद लोडिंग हटाने के लिए एक निर्धारित कार्य जोड़ा है। अन्य सभी मामलों में इसकी आवश्यकता नहीं है।

अद्यतन 2 :

अब वर्तमान 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
आपने संभवतः onPageStarted के डॉक में चेतावनी पर ध्यान दिया है: onPageStarted को तब नहीं कहा जाएगा जब एक एम्बेडेड फ्रेम की सामग्री बदल जाए, अर्थात लिंक पर क्लिक करना जिसका लक्ष्य एक आइफ्रेम है। तो यह उन मामलों में तर्क को तिरछा कर सकता है। BTW, @ पोलेन का सरलीकरण वास्तव में काम करता है?
a00b

1
अच्छी पकड़, फ्रेम सामान पर कभी ध्यान नहीं दिया। मैंने पोलेन के कोड की कोशिश नहीं की है .. केवल यह कि मैं उस काम का आश्वासन दे सकता हूं जो ऊपर का उपयोग कर रहा है।
neteinstein

3
बस एक मामूली सुधार। यह वास्तव में "public void onPageStarted (WebView view, String url, Bitmap favicon)" के बजाय "public void onPageStarted (WebView view, String url)" है
MrMaffad

कुछ नई साइटों के लिए काम नहीं करता है जो कभी भी लोडिंग खत्म नहीं करती हैं ... जैसे, "आराम से"। आपको कभी भी OnPageFinished कॉल नहीं मिलता क्योंकि यह एक रीडायरेक्ट है।
kenyee

मैंने देखा है onPageFinished को एक रीडायरेक्ट के दौरान दो बार कॉल किया जा रहा है। लेकिन, आपने जो कहा है "यदि आपके पास एक पृष्ठ में कई iframes हैं, तो आपके पास कई onPageFinished (और onPageStarted) होंगे" onPageFinished के प्रलेखन के अनुसार सही नहीं है: "इस पद्धति को केवल मुख्य फ्रेम के लिए कहा जाता है।"
गार्नेट

40

मैं @NeTeInStEiN (और @polen) समाधान के लिए बहुत ही आंशिक हूं, लेकिन इसे कई बूलियन या स्टेट वॉचर्स के बजाय एक काउंटर के साथ लागू किया होगा (सिर्फ एक और स्वाद लेकिन मुझे लगा कि शेयर कर सकते हैं)। इसके बारे में एक जेएस बारी है लेकिन मुझे लगता है कि तर्क को समझना थोड़ा आसान है।

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
आपको कोड अच्छा लग रहा है। मैं अपने वेबव्यू के लिए वही कोशिश कर रहा हूं जो html डेटा से लोड होता है url से नहीं। लेकिन यह तब चालू होता है जब पहला वेबव्यू जल्दी लोड होता है और दूसरा लोड होने से पहले। सामान्य परिदृश्य। रनिंग = 1, रनिंग = 2, --running = 1, --running = 0। असामान्य परिदृश्य जो विफल रहता है - चल रहा है = 1, - बहतरीन = 0, चल रहा है = 1 चल रहा है = 0
अजीत मेमना

1
एक अन्य परिदृश्य भी है, जब किसी कारणवश किसी कारणवश फायर नहीं किया जाता है तो TODO भाग तक कभी नहीं पहुंचा जा सकता है। इसलिए आपको टाइमआउट की जाँच के लिए एक टाइमर की आवश्यकता है। या आप सब कुछ ठीक से लोड होने पर जानते हैं कि आप जावास्क्रिप्ट में एक निर्यात जावा फ़ंक्शन को कॉल कर सकते हैं। डॉक्यूमेंटरी की तरह कुछ () या ऐसा कुछ।
कोडबीट

क्यों नहीं बस running = 1;में onPageStarted()?
चोलत्स्की

@Choletski क्योंकि 1 की अधिकतम और 1 से बड़ी संख्या 1. नहीं है
मैथ्यू पढ़ें

25

मैं एक सुंदर समाधान के रूप में अच्छी तरह से पाया है, हालांकि यह कठोरता से परीक्षण नहीं किया है:

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
मैंने इसका परीक्षण किया है और यह पूरी तरह से काम कर रहा है, आप निश्चित रूप से इसे ऑनपंजीफाइन विधि के बाहर से कॉल कर सकते हैं और कम अंतराल में जांच करने के लिए हैंडलर का उपयोग कर सकते हैं - मामलों में, आप WebViewClient वर्ग का विस्तार नहीं करना चाहते हैं।
गल रोम

1
मेरा मानना ​​है कि यह स्वीकार किए गए उत्तर से बेहतर हो सकता है, आपको सिर्फ ऑनर्र की जांच करनी होगी और आपको सेट करना होगा।
Evin1_

1
यह स्वीकृत उत्तर होना चाहिए।
زياد

1
इस एक के लिए
अपवोट

23

मैंने इस तरह होने के लिए NeTeInStEiN के कोड को सरल बनाया है :

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

        }
 });

यह समझना आसान है, OnPageFinished यदि पिछले कॉलबैक onPageStarted पर है, तो पृष्ठ पूरी तरह से लोड हो जाता है।


3
@polen PAGE_STARTED कभी साफ़ नहीं होता है? क्या होगा अगरOverrideUrlLoading () कभी नहीं कहा जाता है?
a00b

20

यदि आप एक प्रगति बार दिखाना चाहते हैं, तो आपको केवल पृष्ठ के पूरा होने के लिए नहीं, बल्कि एक प्रगति परिवर्तन कार्यक्रम के लिए सुनना होगा:

mWebView.setWebChromeClient(new WebChromeClient(){

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

                //change your progress bar
            }


        });

यदि आप चाहते हैं कि BTW केवल इंडेटेरिमनेट प्रोग्रेसबेर को प्रदर्शित करे, जो ऑनपेंज विधि को ओवरराइड करने के लिए पर्याप्त है



5

आप द्वारा प्रगति staus ट्रेस कर सकते हैं getProgress में विधि वेबव्यू वर्ग।

प्रगति की स्थिति का आरम्भ

private int mProgressStatus = 0;

फिर इस तरह लोड करने के लिए AsyncTask:

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 (); UI थ्रेड से कॉल करने की आवश्यकता है।
स्काईनेट

5

उत्तर के लिए धन्यवाद। इससे मुझे मदद मिली, लेकिन मुझे अपनी जरूरतों के लिए इसे थोड़ा सुधारना पड़ा। मेरे पास कई पेजस्टार्ट्स और फिनिश थे इसलिए मैंने एक टाइमर जोड़ा, जो चेक करता है कि क्या पेजफिनिश को नया पॉवरस्टार्ट शुरू किया गया है। ठीक है, बुरा स्पष्टीकरण। कोड देखें :)

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

यहां URL के लिए एक उपन्यास विधि का पता लगाया गया है जब एक URL ने जावास्क्रिप्ट हुक के लिए एंड्रॉइड की क्षमता का उपयोग करके लोड किया है । इस पैटर्न का उपयोग करते हुए, हम एंड्रॉइड रनटाइम के भीतर एक देशी विधि कॉल उत्पन्न करने के लिए दस्तावेज़ के राज्य के जावास्क्रिप्ट के ज्ञान का शोषण करते हैं। ये जावास्क्रिप्ट-सुलभ कॉल @JavaScriptInterfaceएनोटेशन का उपयोग करके किए जा सकते हैं ।

इस कार्यान्वयन के लिए आवश्यक है कि हम सेटिंग setJavaScriptEnabled(true)पर कॉल करें WebView, इसलिए यह आपके एप्लिकेशन की आवश्यकताओं, जैसे सुरक्षा चिंताओं के आधार पर उपयुक्त नहीं हो सकता है

src / io / github / cawfree / webviewcallback / MainActivity.java (जेली बीन, एपीआई स्तर 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;
    }

}

रेस / लेआउट / 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"
/>

अनिवार्य रूप से, हम एक अतिरिक्त जावास्क्रिप्ट फ़ंक्शन को जोड़ रहे हैं जिसका उपयोग दस्तावेज़ की स्थिति का परीक्षण करने के लिए किया जाता है। अगर यह भरा हुआ है, तो हम onPageLoaded()एंड्रॉइड में एक कस्टम इवेंट लॉन्च करते हैं MainActivity; अन्यथा, हम एक ईवेंट श्रोता को पंजीकृत करते हैं जो एक बार पृष्ठ तैयार होने पर, अपडेट का उपयोग करके एंड्रॉइड को अपडेट करता है window.addEventListener('onload', ...);

चूँकि कॉल के बाद हम इस स्क्रिप्ट को जोड़ this.getWebView().loadURL("")रहे हैं, इसलिए यह संभव है कि हमें घटनाओं के लिए 'सुनने' की आवश्यकता न हो , क्योंकि हमें केवल एक नियमित कॉल करके जावास्क्रिप्ट हुक को जोड़ने का मौका मिलता है। loadURL, एक बार पृष्ठ लोड होने के बाद।


बहुत बढ़िया समाधान, जो आम तौर पर काम करता है। मुझे https://reddit.com/r/Nature (आमतौर पर Reddit के साथ) के साथ समस्या हो रही है , जब आप किसी थ्रेड पर क्लिक करते हैं और थ्रेड लोड होता है, तो मैं उस ईवेंट को नहीं पकड़ पा रहा हूं। क्या तुम मेरी मदद कर सकते हो?
प्रिमो क्रालज

@ PrimožKralj मुझे खुशी है कि आप इसके साथ कुछ सफलता पा रहे हैं ... मुझे यकीन नहीं है कि विशेष रूप से सुझाव देने के लिए क्या है, लेकिन अगर किसी भी तरह की सार्वजनिक घटनाएं होती हैं, जो आपको पता चल जाती हैं कि आप हुक कर सकते हैं, उदाहरण के लिए जब टिप्पणी गणना अपडेट की गई है, आप स्रोत के रूप में इसका उपयोग कर सकते हैं। क्या आपने माना है कि शायद Reddit की API को सीधे हिट करने से आपकी समस्या ठीक हो सकती है ?
Mapsy

1
धन्यवाद, मैं ट्रिगर की गई घटनाओं पर एक और नज़र डालूंगा और उनमें से एक को हुक करने की कोशिश करूंगा। मुझे एपीआई के बारे में पता है, और भविष्य में इसका उपयोग करके अधिक मजबूत समाधान को लागू करने का प्रयास करूंगा। धन्यवाद!
प्रिमो क्रालज

1

बस प्रगति बार दिखाने के लिए, "onPageStarted" और "onPageFinished" तरीके पर्याप्त हैं; लेकिन अगर आप एक "is_loading" ध्वज (पृष्ठ पुनर्निर्देशित, ...) के साथ चाहते हैं, तो यह विधि गैर-अनुक्रमण के साथ निष्पादित की जा सकती है, जैसे "onPageStarted> onPageStarted> onPageFartished> onPageFinished" कतार।

लेकिन मेरे छोटे परीक्षण के साथ (इसे स्वयं परीक्षण करें), "ऑनप्रोन्गचैंज" विधि मान कतार "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);
    }
}

is_loading = falseगतिविधि बंद होने पर भी " " सेट करें , यदि यह एक स्थिर चर है क्योंकि गतिविधि पेज खत्म होने से पहले समाप्त हो सकती है।


0

Url को लोड करें SwipeRefreshLayoutऔर 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

यहां एक विधि है जो आपको Runnableएक विशेष वेब पते को लोड करने के बाद एक बार निष्पादित करने के लिए पंजीकृत करने की अनुमति देती है । हम एक सहयोगी Runnableको उससे संबंधित यूआरएल के साथ Stringएक में Map, और हम का उपयोग WebViewकी getOriginalUrl()विधि उचित कॉलबैक चयन करने के लिए।

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

रेंडरर तब रेंडरिंग समाप्त नहीं करेगा जब ऑनपेजफिंसहेड विधि को कॉल किया जाता है या प्रगति 100% तक पहुंच जाती है, इसलिए दोनों तरीके आपको गारंटी नहीं देते हैं कि दृश्य पूरी तरह से प्रस्तुत किया गया था।

लेकिन आप OnLoadResource विधि से यह पता लगा सकते हैं कि पहले से क्या प्रस्तुत किया गया है और अभी भी क्या प्रदान कर रहा है। और इस विधि को कई बार कहा जाता है।

        @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

इस का उपयोग करें यह मदद करनी चाहिए। @var currentUrl = "google.com" var partOfUrl = currentUrl.substring (0, currentUrl.length-2)

webView.setWebViewClient (ऑब्जेक्ट: 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.
}

// आपको त्रुटि के लिए अन्य ओवरराइड विधि को भी ओवरराइड करना चाहिए जैसे onReceiveError यह देखने के लिए कि इन सभी तरीकों को एक के बाद एक कैसे कहा जाता है और ब्रेक पॉइंट के साथ डिबगिंग करते समय वे कैसे व्यवहार करते हैं। } `


-1

Kotlin उपयोगकर्ताओं के लिए:

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

बहुत सारे तरीके हैं जो आप हालांकि ओवरराइड कर सकते हैं

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.