Refactor HTTP calls to use okhttp-coroutines

Author: prof18

gradle/libs.versions.toml

@@ -35,6 +35,7 @@ activity-compose = "1.9.3"
 [libraries]
 # Library dependencies
 com-squareup-okhttp3 = { module = "com.squareup.okhttp3:okhttp", version.ref = "com-squareup-okhttp3" }
+com-squareup-okhttp3-coroutines = { module = "com.squareup.okhttp3:okhttp-coroutines", version.ref = "com-squareup-okhttp3" }
 org-robolectric = { module = "org.robolectric:robolectric", version.ref = "org-robolectric" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
 kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "coroutines" }

rssparser/build.gradle.kts

@@ -112,6 +112,7 @@ kotlin {
 
         get("jvmAndroidMain").dependencies {
             api(libs.com.squareup.okhttp3)
+            implementation(libs.com.squareup.okhttp3.coroutines)
         }
 
         get("webMain").dependencies {

rssparser/src/jvmAndroidMain/kotlin/com/prof18/rssparser/internal/JvmXmlFetcher.kt

@@ -1,15 +1,9 @@
 package com.prof18.rssparser.internal
 
 import com.prof18.rssparser.exception.HttpException
-import kotlinx.coroutines.suspendCancellableCoroutine
 import okhttp3.Call
-import okhttp3.Callback
 import okhttp3.Request
-import okhttp3.Response
-import java.io.IOException
-import java.io.InputStream
-import kotlin.coroutines.resume
-import kotlin.coroutines.resumeWithException
+import okhttp3.coroutines.executeAsync
 
 internal class JvmXmlFetcher(
     private val callFactory: Call.Factory,
@@ -18,71 +12,37 @@ internal class JvmXmlFetcher(
     override suspend fun fetchXml(url: String): ParserInput {
         val request = createRequest(url)
         val baseUrl = request.url.scheme + "://" + request.url.host
+        val response = callFactory.newCall(request).executeAsync()
+        if (!response.isSuccessful) {
+            val exception = HttpException(
+                code = response.code,
+                message = response.message,
+            )
+            response.close()
+            throw exception
+        }
         return ParserInput(
-            inputStream = callFactory.newCall(request).awaitForInputStream(),
+            inputStream = response.body.byteStream(),
             baseUrl = baseUrl,
         )
     }
 
     override suspend fun fetchXmlAsString(url: String): String {
         val request = createRequest(url)
-        return callFactory.newCall(request).awaitForString()
+        val response = callFactory.newCall(request).executeAsync()
+        if (!response.isSuccessful) {
+            val exception = HttpException(
+                code = response.code,
+                message = response.message,
+            )
+            response.close()
+            throw exception
+        }
+        return response.body.string()
     }
 
     private fun createRequest(url: String): Request =
         Request.Builder()
             .url(url)
             .build()
-
-    private suspend fun Call.awaitForInputStream(): InputStream = suspendCancellableCoroutine { continuation ->
-        continuation.invokeOnCancellation {
-            cancel()
-        }
-
-        enqueue(object : Callback {
-            override fun onResponse(call: Call, response: Response) {
-                if (response.isSuccessful) {
-                    val body = requireNotNull(response.body)
-                    continuation.resume(body.byteStream())
-                } else {
-                    val exception = HttpException(
-                        code = response.code,
-                        message = response.message,
-                    )
-                    response.close()
-                    continuation.resumeWithException(exception)
-                }
-            }
-
-            override fun onFailure(call: Call, e: IOException) {
-                continuation.resumeWithException(e)
-            }
-        })
-    }
-
-    private suspend fun Call.awaitForString(): String = suspendCancellableCoroutine { continuation ->
-        continuation.invokeOnCancellation {
-            cancel()
-        }
-
-        enqueue(object : Callback {
-            override fun onResponse(call: Call, response: Response) {
-                if (response.isSuccessful) {
-                    val body = requireNotNull(response.body)
-                    continuation.resume(body.string())
-                } else {
-                    val exception = HttpException(
-                        code = response.code,
-                        message = response.message,
-                    )
-                    response.close()
-                    continuation.resumeWithException(exception)
-                }
-            }
-
-            override fun onFailure(call: Call, e: IOException) {
-                continuation.resumeWithException(e)
-            }
-        })
-    }
 }