Comprehensive Guide to WebView Page Loading Completion Listening in Android

Overview of WebView Page Loading Monitoring Mechanism

In Android application development, WebView serves as a core component for displaying web content, and accurate monitoring of its loading state is crucial for user experience. When a WebView loads pages from the network, developers typically need to display progress indicators (such as ProgressBar) to inform users of the current loading status and hide these indicators upon completion.

Basic Implementation: The onPageFinished Method

Android provides the WebViewClient class to handle various events of WebView, where the onPageFinished(WebView view, String url) method is specifically designed to listen for page loading completion events. This method is called when the WebView finishes loading the main page, making it an ideal location for handling completion logic.

The basic implementation code is as follows:

webView.setWebViewClient(new WebViewClient() {
    @Override
    public void onPageFinished(WebView view, String url) {
        super.onPageFinished(view, url);
        // Hide loading progress bar
        progressBar.setVisibility(View.GONE);
        // Other post-loading processing logic
    }
});

In this implementation, we create a WebViewClient instance and override the onPageFinished method. When page loading completes, the system automatically calls this method, allowing developers to perform operations such as hiding progress bars and updating interface states.

Enhanced Solutions for Complex Scenarios

While the basic implementation works for most simple scenarios, more precise control mechanisms are needed when dealing with complex situations like page redirects and iframe nesting. The following enhanced solution addresses these issues by combining multiple callback methods:

private boolean loadingFinished = true;
private boolean redirect = false;

webView.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 progress bar
        progressBar.setVisibility(View.VISIBLE);
    }

    @Override
    public void onPageFinished(WebView view, String url) {
        if (!redirect) {
            loadingFinished = true;
            // Hide loading progress bar
            progressBar.setVisibility(View.GONE);
        } else {
            redirect = false;
        }
    }
});

Key Mechanism Analysis

The core of this enhanced solution lies in using two state variables, loadingFinished and redirect, to precisely track the loading process:

shouldOverrideUrlLoading method: Called when the WebView needs to load a new URL. If the current page hasn't finished loading (!loadingFinished), it marks the redirect state and resets the loading completion flag.

onPageStarted method: Called each time a page starts loading, ensuring the loading state is correctly set to in-progress and displaying the progress indicator.

onPageFinished method: Only considers the page truly loaded when not in a redirect situation, avoiding misjudgments caused by intermediate redirects.

Handling Special Scenarios

It's important to note that in certain specific cases, such as changes in embedded frame (iframe) content, onPageStarted might not be called. For such edge cases, consider adding a timeout mechanism as a supplement:

// Add timeout handling as a safety mechanism
new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        if (!loadingFinished) {
            progressBar.setVisibility(View.GONE);
            loadingFinished = true;
        }
    }
}, 10000); // 10-second timeout

Best Practice Recommendations

In practical development, it's recommended to choose the appropriate implementation based on specific requirements: for simple page loading scenarios, the basic implementation is sufficient; for pages containing redirects, multiple frames, or complex interactions, the enhanced solution is recommended to ensure accurate loading state judgment.

Additionally, pay attention to memory management and lifecycle coordination, ensuring timely cleanup of WebView-related resources when Activities or Fragments are destroyed to avoid memory leakage issues.