Hey there! I’ve dealt with exactly these WebView-related headaches before, so let’s walk through solutions step by step.

The root issue here is that ScrollView doesn’t automatically re-calculate its child views’ sizes unless explicitly told, and WebView won’t report its updated content height after loading a new page by default. Here’s how to fix it:

• First, make sure your WebView’s layout params are set to wrap_content in XML or code. But this alone isn’t enough—you need to dynamically fetch the actual content height via JavaScript and update the WebView’s size.
• Implement a WebViewClient and use the onPageFinished callback to run JS that gets the page height, then adjust the WebView’s layout:

webView.setWebViewClient(new WebViewClient() {
    @Override
    public void onPageFinished(WebView view, String url) {
        super.onPageFinished(view, url);
        // Fetch page height via JavaScript
        view.evaluateJavascript("document.body.scrollHeight", new ValueCallback<String>() {
            @Override
            public void onReceiveValue(String value) {
                try {
                    int contentHeight = Integer.parseInt(value);
                    // Update WebView height
                    ViewGroup.LayoutParams params = view.getLayoutParams();
                    params.height = contentHeight;
                    view.setLayoutParams(params);
                    // Force ScrollView to re-layout
                    ((ScrollView) view.getParent()).requestLayout();
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                }
            }
        });
    }
});

• Don’t forget to enable JavaScript in your WebView settings:

webView.getSettings().setJavaScriptEnabled(true);

• If your page has lazy-loaded content (like images), onPageFinished might trigger before all content loads. In that case, either listen for onProgressChanged to wait for 100% progress, or have the H5 page send a native callback via a JS bridge once all content is ready.

The solution above already handles adjusting the WebView’s height to match content, but here are extra options depending on what you need:

• Scale content to fit WebView width: Use these settings to make the page adapt to the device screen without horizontal scrolling:

WebSettings settings = webView.getSettings();
settings.setLoadWithOverviewMode(true);
settings.setUseWideViewPort(true);

• Manual scaling: If you need to adjust zoom level, use webView.setInitialScale(100); (100 = no scaling) or let users pinch-to-zoom with settings.setBuiltInZoomControls(true);.
• Dynamic content updates: If the page content changes after initial load (e.g., user interactions), have the H5 call a native method via JS to trigger a height recalculation instead of reloading the page.

WebView instances are resource-heavy, so reusing them with a pool cuts down on memory usage and load times. Here’s a practical, battle-tested implementation:

Core Pool Class #

public class WebViewPool {
    private static final int MAX_POOL_SIZE = 3; // Adjust based on your app's needs (2-3 is ideal)
    private static WebViewPool instance;
    private final LinkedList<WebView> pool;

    private WebViewPool() {
        pool = new LinkedList<>();
    }

    public static WebViewPool getInstance() {
        if (instance == null) {
            synchronized (WebViewPool.class) {
                if (instance == null) {
                    instance = new WebViewPool();
                }
            }
        }
        return instance;
    }

    // Get a WebView from the pool, or create a new one if empty
    public WebView acquireWebView(Context context) {
        if (!pool.isEmpty()) {
            WebView webView = pool.removeFirst();
            resetWebViewState(webView);
            return webView;
        }
        return createNewWebView(context);
    }

    // Return a WebView to the pool, or destroy it if pool is full
    public void releaseWebView(WebView webView) {
        if (webView == null) return;

        // Remove from parent layout first
        ViewGroup parent = (ViewGroup) webView.getParent();
        if (parent != null) {
            parent.removeView(webView);
        }

        if (pool.size() < MAX_POOL_SIZE) {
            resetWebViewState(webView);
            pool.addLast(webView);
        } else {
            webView.destroy();
        }
    }

    // Reset WebView to avoid cross-contamination between uses
    private void resetWebViewState(WebView webView) {
        webView.stopLoading();
        webView.loadUrl("about:blank");
        webView.clearHistory();
        webView.clearCache(true);
        // Reset listeners to prevent memory leaks
        webView.setWebViewClient(null);
        webView.setWebChromeClient(null);
        // Re-enable core settings (adjust based on your app's needs)
        WebSettings settings = webView.getSettings();
        settings.setJavaScriptEnabled(true);
        settings.setDomStorageEnabled(true);
    }

    // Create a new pre-configured WebView
    private WebView createNewWebView(Context context) {
        WebView webView = new WebView(context);
        WebSettings settings = webView.getSettings();
        settings.setJavaScriptEnabled(true);
        settings.setDomStorageEnabled(true);
        settings.setLoadWithOverviewMode(true);
        settings.setUseWideViewPort(true);
        return webView;
    }

    // Clear the pool when the app exits to prevent memory leaks
    public void clearPool() {
        for (WebView webView : pool) {
            webView.destroy();
        }
        pool.clear();
    }
}

Usage Example #

// Acquire a WebView
WebView webView = WebViewPool.getInstance().acquireWebView(this);
// Add to your ScrollView
scrollView.addView(webView);
// Load your URL
webView.loadUrl("https://your-page.com");

// When done with the WebView (e.g., fragment destroy)
WebViewPool.getInstance().releaseWebView(webView);

Key Notes #

• Always reset state: Failing to clear history/cache or remove listeners will cause memory leaks and unexpected behavior with reused WebViews.
• Limit pool size: Too many WebViews in the pool will waste memory—stick to 2-3 unless you have a specific need for more.
• Handle process death: If your app uses multiple processes, each process needs its own WebView pool (WebViews can’t be shared across processes).

内容的提问来源于stack exchange，提问作者nameless