Sending a large request in a WebView

I have some srt files and I want to translate them into Kurdish because the lack of translation in this language, instead of using an API which I can't afford, I'm using WebView to pass the string inside the srt to the query, and to get the translation using a Javascript interface.

This works fine when the string is small, for example a few thousand characters, but when passing the whole string inside the srt I get an error (of course) because of the large request.

So I need help with finding a way to make this work.

This is the function for setting up the WebView:

fun setupWebView(
    input: String,
    from: String,
    into: String,
    webView: WebView,
    resultHandler: (String) -> Unit
) {
    val url =
        "https://translate.google.com/?sl=$from&tl=$into&text=${input.dropLast(70000)}&op=translate"

    webView.addJavascriptInterface(JsInterface, "JsInterface")

    webView.loadUrl(url)

    JsInterface.setResultCallback {
        resultHandler(it)
    }


    webView.settings.javaScriptEnabled = true


    webView.webViewClient = object : WebViewClient() {
        override fun onPageFinished(view: WebView?, url: String?) {
            super.onPageFinished(view, url)
            view?.postDelayed({
                injectJavascript(view)
            }, 1000)
        }
    }
}

This seems related to your other question, in the sense that it is also dealing with the limitations of the loadUrl function in Android's WebView.

The loadUrl method in WebView accepts a string URL to load a webpage. However, URLs have a maximum length limit. According to the HTTP protocol, there is no limit, but most web browsers and servers limit URL length to keep them manageable. The widely accepted maximum length is 2000 characters. If you are trying to pass a very large string to loadUrl through a URL query parameter, it could easily exceed this limit, leading to issues.

In your case, it seems you are trying to translate a large amount of text by passing it as a URL parameter to a translation website. This is likely exceeding the URL length limit, causing an error.

You would need to find a way to divide the large string into smaller chunks that are small enough to fit within the URL length limit, and then process each chunk separately. As in your second question: divide the text into chunks, create a URL for each chunk, and then load each URL one at a time in the WebView.

However, this approach has limitations. Translating text chunk by chunk may lead to incorrect translations, as the context of the whole text is not taken into account during each translation. Also, automated translation services like Google Translate have usage policies that could prevent or limit this kind of usage.

It would be more appropriate to use a translation API designed for large amounts of text, but you mentioned that this is not an affordable option for you. In that case, you might want to look for other free or more affordable translation APIs, or consider using machine learning models for translation that you could run locally on the device.

import android.os.Handler
import android.os.Looper
import android.webkit.WebView
import android.webkit.WebViewClient
import java.io.ByteArrayOutputStream
import java.io.OutputStreamWriter
import java.net.HttpURLConnection
import java.net.URL

fun setupWebView(
    input: String,
    from: String,
    into: String,
    webView: WebView,
    resultHandler: (String) -> Unit
) {
    val postData = "sl=$from&tl=$into&text=${input.dropLast(70000)}&op=translate"

    webView.addJavascriptInterface(JsInterface, "JsInterface")
    webView.settings.javaScriptEnabled = true

    webView.webViewClient = object : WebViewClient() {
        override fun onPageFinished(view: WebView?, url: String?) {
            super.onPageFinished(view, url)
            view?.postDelayed({
                injectJavascript(view)
            }, 1000)
        }
    }

    val handler = Handler(Looper.getMainLooper())

    Thread {
        try {
            val postUrl = URL("https://translate.google.com")
            val conn = postUrl.openConnection() as HttpURLConnection

            conn.requestMethod = "POST"
            conn.doOutput = true

            conn.connectTimeout = 5000
            conn.readTimeout = 5000

            val out = conn.outputStream
            val writer = OutputStreamWriter(out, "UTF-8")

            writer.write(postData)
            writer.flush()
            writer.close()

            val inputStream = conn.inputStream
            val buffer = ByteArrayOutputStream()

            inputStream.use { input ->
                val data = ByteArray(1024)
                var bytesRead: Int
                while (input.read(data).also { bytesRead = it } != -1) {
                    buffer.write(data, 0, bytesRead)
                }
            }

            val html = buffer.toString("UTF-8")

            handler.post {
                webView.loadDataWithBaseURL("https://translate.google.com", html, "text/html", "UTF-8", null)
            }

            JsInterface.setResultCallback { resultHandler(it) }
        } catch (e: Exception) {
            // Handle exceptions here
        }
    }.start()
}