Android webview intercepts H5's interface request and returns the processed data code example

// Kotlin code example = object : WebViewClient() {
    // For API 21 and later    override fun shouldInterceptRequest(
        view: WebView, 
        request: WebResourceRequest
    ): WebResourceResponse? {
        val url = ()
        // Here you can judge the URL and intercept or modify the request as needed        if (("your_target_url")) {
            // Some processing can be done here, such as replacing the request or returning local data            val inputStream = ... // Custom input stream            return WebResourceResponse("text/html", "UTF-8", inputStream)
        }
        // Don't intercept, continue to request        return (view, request)
    }
    
    // For API 11 to API 20 devices    override fun shouldInterceptRequest(
        view: WebView, 
        url: String
    ): WebResourceResponse? {
        // The processing logic here is similar to the above code        if (("your_target_url")) {
            // Custom processing logic            val inputStream = ... 
            return WebResourceResponse("text/html", "UTF-8", inputStream)
        }
        return (view, url)
    }
}

 = object : WebViewClient() {
    override fun shouldInterceptRequest(
        view: WebView, 
        request: WebResourceRequest
    ): WebResourceResponse? {
        val url = ()

        // Determine whether it is an interface request that needs to be intercepted        if (("your_api_endpoint")) {
            //Stamp the request via OkHttp or HttpURLConnection            val response = fetchApiData(url)

            // Pass the retrieved response content to H5             {
                ("javascript:handleApiResponse('${response}')", null)
            }

            // Return an empty response or custom content            return WebResourceResponse("application/json", "UTF-8", null)
        }

        return (view, request)
    }

    // Use OkHttp to initiate network requests (you can choose the appropriate network library according to your needs)    private fun fetchApiData(url: String): String {
        // Simple OkHttp request example        val client = OkHttpClient()
        val request = ().url(url).build()

        (request).execute().use { response ->
            return ?.string() ?: ""
        }
    }
}

function handleApiResponse(response) {
    ("API Response: ", response);
    // Here you can process the response, render to the page, etc.}

(object {
    @JavascriptInterface
    fun sendDataToH5(data: String) {
        // Send data to H5        ("javascript:handleApiResponse('$data')", null)
    }
}, "AndroidInterface")

 = object : WebViewClient() {
    override fun shouldInterceptRequest(
        view: WebView, 
        request: WebResourceRequest
    ): WebResourceResponse? {
        val url = ()
        
        if (("your_api_endpoint")) {
            val response = fetchApiData(url)
            
            // Pass data to H5 through JavaScript interface             {
                ("javascript:AndroidInterface.sendDataToH5('${response}')", null)
            }
            
            return WebResourceResponse("application/json", "UTF-8", null)
        }
        return (view, request)
    }
}

override fun shouldInterceptRequest(
    view: WebView, 
    request: WebResourceRequest
): WebResourceResponse? {
    val url = ()
    val method =   // Get request method such as GET or POST
    // Process according to the request type    if (method == "POST") {
        // Get the body requested by POST (in Android WebView, it is not supported to directly obtain the POST body unless a specific tool is used)        // Custom logic processing POST requests    } else if (method == "GET") {
        // Process GET requests    }

    return (view, request)
}

override fun shouldInterceptRequest(
    view: WebView, 
    request: WebResourceRequest
): WebResourceResponse? {
    val url = ()
    val method =   // Get request method such as GET or POST
    if (method == "POST") {
        // Customize the HTTP request to process POST request body and response        val response = performCustomHttpPost(url, request)
        return WebResourceResponse("application/json", "UTF-8", response)
    }

    return (view, request)
}

fun performCustomHttpPost(url: String, request: WebResourceRequest): InputStream {
    // Send custom POST requests using OkHttp or HttpURLConnection    val client = OkHttpClient()
    val requestBody = ... // Build the request body
    val request = ()
        .url(url)
        .post(requestBody)
        .build()

    val response = (request).execute()
    return ?.byteStream() ?: ByteArrayInputStream(ByteArray(0))
}

override fun shouldInterceptRequest(
    view: WebView, 
    request: WebResourceRequest
): WebResourceResponse? {
    val url = ()
    val headers = 
    val acceptHeader = headers["Accept"]  // Get the Accept header
    // Determine whether it is a script request (script)    if ((".js") || acceptHeader?.contains("application/javascript") == true) {
        ("WebView", "Intercept script request: $url")
        // You can intercept or modify script requests here    }

    // Determine whether it is an XHR request (judged by URL or Accept header)    if (("/api/") || acceptHeader?.contains("application/json") == true) {
        ("WebView", "Intercepted XHR request: $url")
        // Here you can intercept or modify XHR requests    }

    // Determine whether it is a CSS request    if ((".css") || acceptHeader?.contains("text/css") == true) {
        ("WebView", "Intercepted CSS request: $url")
        // CSS requests can be intercepted or modified here    }

    // Requests for other resource types    ("WebView", "Other types of requests: $url")
    
    return (view, request)
}

if ((".js") || acceptHeader?.contains("application/javascript") == true || acceptHeader?.contains("text/javascript") == true) {
    ("WebView", "Intercepted JavaScript request: $url")
}

if (("/api/") || acceptHeader?.contains("application/json") == true || headers["X-Requested-With"] == "XMLHttpRequest") {
    ("WebView", "Intercepted XHR request: $url")
}

if ((".woff") || (".woff2") || (".ttf") || (".otf") || acceptHeader?.contains("font/") == true) {
    ("WebView", "Intercepted font file request: $url")
}

if ((".png") || (".jpg") || (".jpeg") || (".gif") || acceptHeader?.contains("image/") == true) {
    ("WebView", "Intercepted image request: $url")
}

if ( == "OPTIONS" && ("Access-Control-Request-Method")) {
    ("WebView", "Intercept Preflight request: $url")
}

override fun shouldInterceptRequest(
    view: WebView, 
    request: WebResourceRequest
): WebResourceResponse? {
    val url = ()
    
    if (("your_api_endpoint")) {
        // Initiate a network request to obtain data        val response = fetchApiData(url)
        
        // Process the returned response stream        val byteStream = ?.byteStream() ?: ByteArrayInputStream(ByteArray(0))
        val contentType = ("Content-Type", "application/json") // Set the default content type        val contentLength = ("Content-Length", "-1").toLong() // Set content length        
        // Build WebResourceResponse and return it to WebView        return WebResourceResponse(
            contentType, // Content Type            "utf-8",     // Encoding format            200,         // HTTP status code            "OK",        // Status Description            mapOf(        // Response header                "Access-Control-Allow-Origin" to "*",
                "Content-Length" to ()
            ),
            byteStream   // Respond to the input stream of content        )
    }

    return (view, request)
}

// Use OkHttp to initiate a network requestprivate fun fetchApiData(url: String): Response {
    val client = OkHttpClient()
    val request = ().url(url).build()

    return (request).execute() // Return the Response object directly}

override fun shouldInterceptRequest(
    view: WebView,
    request: WebResourceRequest
): WebResourceResponse? {
    val url = ()
    val method = 

    if (method == "POST") {
        ("WebView", "Intercepted POST request: $url")

        // Customize the processing of POST requests, build the request body and send it        val responseStream = performCustomHttpPost(url, request)

        // Returns a custom WebResourceResponse        return WebResourceResponse(
            "application/json", // Assume that the return is a JSON response            "UTF-8",
            200, // HTTP status code            "OK", // HTTP status description            mapOf("Access-Control-Allow-Origin" to "*"), // Response header            responseStream // Input stream for response data        )
    }

    return (view, request)
}

// Customize the logic of processing POST requestsfun performCustomHttpPost(url: String, request: WebResourceRequest): InputStream {
    // Build a POST request body (assuming that the POST data sent by the H5 side is in JSON format)    val postData = getPostData(request) // Assume that the request volume data can be extracted here
    // Logging request volume data    ("WebView", "POST request data: $postData")

    // Use OkHttp to send a custom POST request    val client = OkHttpClient()
    val requestBody = (
        ("application/json; charset=utf-8"), // Assume that the request body is JSON data        postData ?: "" // POST requested data    )

    val customRequest = ()
        .url(url)
        .post(requestBody)
        .build()

    // Initiate a request and return the response stream    val response = (customRequest).execute()

    ("WebView", "HTTP Response code: ${()}") // Logging response status code
    return ?.byteStream() ?: ByteArrayInputStream(ByteArray(0))
}

// Get POST data (need to be obtained through front-end or other means)fun getPostData(request: WebResourceRequest): String? {
    // WebView cannot directly obtain POST body data, and the front-end needs to cooperate to pass it through evaluateJavascript or other methods.    // Suppose we get some data from requestHeaders (actually, it can be modified according to your needs)    val contentType = ["Content-Type"]
    ("WebView", "Content-Type: $contentType")

    // Here we return the simulated POST data, which needs to be processed in actual situations.    return "{ \"key\": \"value\" }"
}

Key points：
Get request body data：Android WebView No access provided by itself POST Direct way to request body，Need to cooperate through front-end（like evaluateJavascript）To pass the request body，Or process the simulation request body by yourself。

Manually build POST Request body：use OkHttp of () 方法Manually build POST Request body。

Logging：

pass () Record拦截of URL 和Request body数据，Easy to debug。
Record HTTP Response status code，Check whether the request is successful。
Handle exceptions：like果响应体为空，返回一个空of ByteArrayInputStream()，To ensure WebView Will not crash。

关于获取真实of POST Request body
Android of WebView Get it directly without a built-in mechanism POST Request body，因此需要pass JavaScript and Android Communication，exist H5 Actively POST Data sent to WebView。例like：

// Get the POST request body on the H5 side and pass it to Androidfunction sendPostDataToAndroid(data) {
    if () {
        ((data));
    }
}

@JavascriptInterface
fun sendPostData(data: String) {
    // Process POST data passed from H5    ("WebView", "Received POST data: $data")
}

            // Determine whether it is an XHR request (judged by URL or Accept header)            if ((("/api/") || acceptHeader?.contains("application/json") == true ||
                        headers["X-Requested-With"] == "XMLHttpRequest") && !("html")) {
                ( "Intercepted XHR request: $url")
                // Here you can intercept or modify XHR requests                var respone: Response? = null
                if(method == "POST"){
                    val params = ("@")
                    val test = params[0]                    // Get the body data requested by POST                    val postData = (params[1], StandardCharsets.UTF_8.toString())
                    ("postData = $postData")
                    respone = fetchApiData2(test,method,postData)
                }else if(method == "GET"){
                    respone = fetchApiData(url,method,null)
                }
                val byteStream = respone?.body()?.byteStream() ?: ByteArrayInputStream(ByteArray(0))
                val contentType = respone?.header("Content-Type", "application/json") // Set the default content type                val contentLength = respone?.header("Content-Length", "-1")?.toLong() // Set content length
                ("fetchApiData respone = ${()}")
                return WebResourceResponse(
                    contentType, // Content Type                    "utf-8",     // Encoding format                    200,         // HTTP status code                    "OK",        // Status Description                    mapOf(        // Response header                        "Access-Control-Allow-Origin" to "*",
                        "Content-Length" to ()
                    ),
                    byteStream   // Respond to the input stream of content                )

//                return WebResourceResponse("application/json", "utf-8",respone)
            }

    private fun fetchApiData2(url: String, method: String, postData: String?): Response{
        ("fetchApiData2 = $url + $method + $postData")
        val client = ()
        val requestBody = (
            ("application/json; charset=utf-8"), // Assume that the request body is JSON data            postData ?: "" // POST requested data        )
        val requestBuilder = ()
            .url(url)
            .post(requestBody)
            .build()

        return (requestBuilder).execute()
    }

    // Process according to the request type    private fun fetchApiData(url: String, method: String, postData: Map<String, String>?): Response  {
        ("fetchApiData = $url + $method + $postData")
        val client = ()
        val requestBuilder = ().url(url)

        //Build a request according to the request type        if (method == "POST" && postData != null) {
            val formBody = ()
             { (key, value) -> (key, value) }

            (())
        }

        val request = ()

        return (request).execute() // Return the Response object directly}