Merge pull request #3 from haroldadmin/suspend-fun-support

feat: Add support for suspending functions with NetworkResponse return type

Author: haroldadmin

build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    id("org.jetbrains.kotlin.jvm").version("1.3.41")
+    id("org.jetbrains.kotlin.jvm").version("1.3.50")
     maven
 }
 
@@ -15,9 +15,9 @@ val test by tasks.getting(Test::class) {
 
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0-RC")
-    implementation("com.squareup.retrofit2:retrofit:2.6.0")
-    implementation("com.squareup.okhttp3:okhttp:4.0.1")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0")
+    implementation("com.squareup.retrofit2:retrofit:2.6.1")
+    implementation("com.squareup.okhttp3:okhttp:4.2.0")
 
     testImplementation("com.squareup.okhttp3:mockwebserver:4.0.1")
     testImplementation("com.google.guava:guava:26.0-jre")

src/main/kotlin/com/haroldadmin/cnradapter/CoroutinesNetworkResponseAdapter.kt

@@ -17,8 +17,14 @@ import java.lang.reflect.Type
  * @constructor Creates a CoroutinesNetworkResponseAdapter
  */
 
-private const val UNKNOWN_ERROR_RESPONSE_CODE = 520
-
+@Deprecated(
+        message = "This class should not be used anymore. Pick DeferredNetworkResponseAdapter or NetworkResponseAdapter based on your needs",
+        replaceWith = ReplaceWith(
+                expression = "DeferredNetworkResponseAdapter",
+                imports = ["com.haroldadmin.cnradapter.DeferredNetworkResponseAdapter"]
+        ),
+        level = DeprecationLevel.WARNING
+)
 internal class CoroutinesNetworkResponseAdapter<T : Any, U : Any>(
     private val successBodyType: Type,
     private val errorConverter: Converter<ResponseBody, U>
@@ -48,6 +54,7 @@ internal class CoroutinesNetworkResponseAdapter<T : Any, U : Any>(
 
         call.enqueue(object : Callback<T> {
             override fun onFailure(call: Call<T>, throwable: Throwable) {
+                // TODO Use ErrorExtraction methods here
                 when (throwable) {
 
                     is IOException -> deferred.complete(NetworkResponse.NetworkError(throwable))

src/main/kotlin/com/haroldadmin/cnradapter/CoroutinesNetworkResponseAdapterFactory.kt

@@ -10,12 +10,23 @@ import java.lang.reflect.Type
 /**
  * A Factory class to create instances of [CoroutinesNetworkResponseAdapter]
  */
+@Deprecated(
+        message = "This class should not be used anymore. Replace with NetworkResponseAdapterFactory",
+        replaceWith = ReplaceWith(
+                expression = "NetworkResponseAdapterFactory",
+                imports = ["com.haroldadmin.cnradapter.NetworkResponseAdapterFactory"]
+        ),
+        level = DeprecationLevel.WARNING
+)
 class CoroutinesNetworkResponseAdapterFactory private constructor() : CallAdapter.Factory() {
 
     companion object {
         @JvmStatic
         @JvmName("create")
-        operator fun invoke() = CoroutinesNetworkResponseAdapterFactory()
+        @Suppress("DEPRECATION")
+        operator fun invoke(): CoroutinesNetworkResponseAdapterFactory {
+            throw UnsupportedOperationException("Use NetworkResponseAdapterFactory instead of this class")
+        }
     }
 
     /**
@@ -26,22 +37,15 @@ class CoroutinesNetworkResponseAdapterFactory private constructor() : CallAdapte
         if (Deferred::class.java != rawType) {
             return null
         }
-        if (returnType !is ParameterizedType) {
-            throw IllegalStateException(
-                    "Deferred return must be parameterized as Deferred<Foo> or Deferred<out Foo>"
-            )
-        }
+
+        check(returnType is ParameterizedType) { "Deferred return must be parameterized as Deferred<Foo> or Deferred<out Foo>" }
 
         val containerType = getParameterUpperBound(0, returnType)
         if (getRawType(containerType) != NetworkResponse::class.java) {
             return null
         }
 
-        if (containerType !is ParameterizedType) {
-            throw IllegalStateException(
-                    "NetworkResponse must be parameterized as NetworkResponse<SuccessBody, ErrorBody>"
-            )
-        }
+        check(containerType is ParameterizedType) { "NetworkResponse must be parameterized as NetworkResponse<SuccessBody, ErrorBody>" }
 
         val successBodyType = getParameterUpperBound(0, containerType)
         val errorBodyType = getParameterUpperBound(1, containerType)
@@ -50,6 +54,7 @@ class CoroutinesNetworkResponseAdapterFactory private constructor() : CallAdapte
                 errorBodyType,
                 annotations
         )
+        @Suppress("DEPRECATION")
         return CoroutinesNetworkResponseAdapter<Any, Any>(successBodyType, errorBodyConverter)
     }
 }

src/main/kotlin/com/haroldadmin/cnradapter/DeferredNetworkResponseAdapter.kt

@@ -0,0 +1,68 @@
+package com.haroldadmin.cnradapter
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Deferred
+import okhttp3.ResponseBody
+import retrofit2.*
+import java.io.IOException
+import java.lang.reflect.Type
+
+/**
+ * A Retrofit converter to return objects wrapped in [NetworkResponse] class
+ *
+ * @param T The type of the successful response model
+ * @param U The type of the error response model
+ * @param successBodyType The type of the successful response model in [NetworkResponse]
+ * @param errorConverter The converter to extract error information from [ResponseBody]
+ * @constructor Creates a DeferredNetworkResponseAdapter
+ */
+
+internal class DeferredNetworkResponseAdapter<T : Any, U : Any>(
+        private val successBodyType: Type,
+        private val errorConverter: Converter<ResponseBody, U>
+) : CallAdapter<T, Deferred<NetworkResponse<T, U>>> {
+
+    /**
+     * This is used to determine the parameterize type of the object
+     * being handled by this adapter. For example, the response type
+     * in Call<Repo> is Repo.
+     */
+    override fun responseType(): Type = successBodyType
+
+    /**
+     * Returns an instance of [T] by modifying a [Call] object
+     *
+     * @param call The call object to be converted
+     * @return The T instance wrapped in a [NetworkResponse] class wrapped in [Deferred]
+     */
+    override fun adapt(call: Call<T>): Deferred<NetworkResponse<T, U>> {
+        val deferred = CompletableDeferred<NetworkResponse<T, U>>()
+
+        deferred.invokeOnCompletion {
+            if (deferred.isCancelled) {
+                call.cancel()
+            }
+        }
+
+        call.enqueue(object : Callback<T> {
+            override fun onFailure(call: Call<T>, throwable: Throwable) {
+                try {
+                    val networkResponse = throwable.extractNetworkResponse<T, U>(errorConverter)
+                    deferred.complete(networkResponse)
+                } catch (t: Throwable) {
+                    deferred.completeExceptionally(t)
+                }
+            }
+
+            override fun onResponse(call: Call<T>, response: Response<T>) {
+                val headers = response.headers()
+                val responseCode = response.code()
+                val body = response.body()
+                body?.let {
+                    deferred.complete(NetworkResponse.Success(it, headers))
+                } ?: deferred.complete(NetworkResponse.ServerError(null, responseCode, headers))
+            }
+        })
+
+        return deferred
+    }
+}

src/main/kotlin/com/haroldadmin/cnradapter/ErrorExtraction.kt

@@ -0,0 +1,34 @@
+package com.haroldadmin.cnradapter
+
+import okhttp3.ResponseBody
+import retrofit2.Converter
+import retrofit2.HttpException
+import java.io.IOException
+
+internal const val UNKNOWN_ERROR_RESPONSE_CODE = 520
+
+internal fun <S : Any, E : Any> HttpException.extractFromHttpException(errorConverter: Converter<ResponseBody, E>): NetworkResponse<S, E> {
+    val error = response()?.errorBody()
+    val responseCode = response()?.code() ?: UNKNOWN_ERROR_RESPONSE_CODE
+    val headers = response()?.headers()
+    val errorBody = when {
+        error == null -> null // No error content available
+        error.contentLength() == 0L -> null // Error content is empty
+        else -> try {
+            // There is error content present, so we should try to extract it
+            errorConverter.convert(error)
+        } catch (e: Exception) {
+            // If unable to extract content, return with a null body and don't parse further
+            return NetworkResponse.ServerError(null, responseCode, headers)
+        }
+    }
+    return NetworkResponse.ServerError(errorBody, responseCode, headers)
+}
+
+internal fun <S : Any, E : Any> Throwable.extractNetworkResponse(errorConverter: Converter<ResponseBody, E>): NetworkResponse<S, E> {
+    return when (this) {
+        is IOException -> NetworkResponse.NetworkError(this)
+        is HttpException -> extractFromHttpException<S, E>(errorConverter)
+        else -> throw this
+    }
+}

src/main/kotlin/com/haroldadmin/cnradapter/Extensions.kt

@@ -15,11 +15,11 @@ import kotlinx.coroutines.delay
  * @return The NetworkResponse value whether it be successful or failed after retrying
  */
 suspend inline fun <T : Any, U : Any> executeWithRetry(
-    times: Int = 10,
-    initialDelay: Long = 100, // 0.1 second
-    maxDelay: Long = 1000, // 1 second
-    factor: Double = 2.0,
-    block: () -> NetworkResponse<T, U>
+        times: Int = 10,
+        initialDelay: Long = 100, // 0.1 second
+        maxDelay: Long = 1000, // 1 second
+        factor: Double = 2.0,
+        block: suspend () -> NetworkResponse<T, U>
 ): NetworkResponse<T, U> {
     var currentDelay = initialDelay
     repeat(times - 1) {

src/main/kotlin/com/haroldadmin/cnradapter/NetworkResponseAdapter.kt

@@ -0,0 +1,20 @@
+package com.haroldadmin.cnradapter
+
+import okhttp3.ResponseBody
+import retrofit2.Call
+import retrofit2.CallAdapter
+import retrofit2.Converter
+import java.lang.reflect.Type
+
+class NetworkResponseAdapter<S : Any, E : Any>(
+        private val successType: Type,
+        private val errorBodyConverter: Converter<ResponseBody, E>
+) : CallAdapter<S, Call<NetworkResponse<S, E>>> {
+
+    override fun responseType(): Type = successType
+
+    override fun adapt(call: Call<S>): Call<NetworkResponse<S, E>> {
+        return NetworkResponseCall(call, errorBodyConverter)
+    }
+}
+

src/main/kotlin/com/haroldadmin/cnradapter/NetworkResponseAdapterFactory.kt

@@ -0,0 +1,43 @@
+package com.haroldadmin.cnradapter
+
+import kotlinx.coroutines.Deferred
+import retrofit2.Call
+import retrofit2.CallAdapter
+import retrofit2.Retrofit
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+
+class NetworkResponseAdapterFactory : CallAdapter.Factory() {
+
+    override fun get(returnType: Type, annotations: Array<Annotation>, retrofit: Retrofit): CallAdapter<*, *>? {
+
+        check(returnType is ParameterizedType) { "$returnType must be parameterized. Raw types are not supported" }
+
+        val containerType = getParameterUpperBound(0, returnType)
+        if (getRawType(containerType) != NetworkResponse::class.java) {
+            return null
+        }
+
+        check(containerType is ParameterizedType) { "$containerType must be parameterized. Raw types are not supported" }
+
+        val (successBodyType, errorBodyType) = containerType.getBodyTypes()
+        val errorBodyConverter = retrofit.nextResponseBodyConverter<Any>(null, errorBodyType, annotations)
+
+        return when (getRawType(returnType)) {
+            Deferred::class.java -> {
+                DeferredNetworkResponseAdapter<Any, Any>(successBodyType, errorBodyConverter)
+            }
+
+            Call::class.java -> {
+                NetworkResponseAdapter<Any, Any>(successBodyType, errorBodyConverter)
+            }
+            else -> null
+        }
+    }
+
+    private fun ParameterizedType.getBodyTypes(): Pair<Type, Type> {
+        val successType = getParameterUpperBound(0, this)
+        val errorType = getParameterUpperBound(1, this)
+        return successType to errorType
+    }
+}

src/main/kotlin/com/haroldadmin/cnradapter/NetworkResponseCall.kt

@@ -0,0 +1,52 @@
+package com.haroldadmin.cnradapter
+
+import okhttp3.Request
+import okhttp3.ResponseBody
+import retrofit2.Call
+import retrofit2.Callback
+import retrofit2.Converter
+import retrofit2.Response
+
+internal class NetworkResponseCall<S : Any, E : Any>(
+        private val backingCall: Call<S>,
+        private val errorConverter: Converter<ResponseBody, E>
+) : Call<NetworkResponse<S, E>> {
+
+    override fun enqueue(callback: Callback<NetworkResponse<S, E>>) = synchronized(this) {
+        backingCall.enqueue(object : Callback<S> {
+            override fun onResponse(call: Call<S>, response: Response<S>) {
+                val body = response.body()
+                if (body != null) {
+                    callback.onResponse(this@NetworkResponseCall, Response.success(NetworkResponse.Success(body, response.headers())))
+                } else {
+                    callback.onResponse(this@NetworkResponseCall, Response.success(NetworkResponse.ServerError(null, response.code(), response.headers())))
+                }
+            }
+
+            override fun onFailure(call: Call<S>, throwable: Throwable) {
+                val networkResponse = throwable.extractNetworkResponse<S, E>(errorConverter)
+                callback.onResponse(this@NetworkResponseCall, Response.success(networkResponse))
+            }
+        })
+    }
+
+    override fun isExecuted(): Boolean = synchronized(this) {
+        backingCall.isExecuted
+    }
+
+    override fun clone(): Call<NetworkResponse<S, E>> = NetworkResponseCall(backingCall.clone(), errorConverter)
+
+    override fun isCanceled(): Boolean = synchronized(this) {
+        backingCall.isCanceled
+    }
+
+    override fun cancel() = synchronized(this) {
+        backingCall.cancel()
+    }
+
+    override fun execute(): Response<NetworkResponse<S, E>> {
+        throw UnsupportedOperationException("Network Response call does not support synchronous execution")
+    }
+
+    override fun request(): Request = backingCall.request()
+}

src/test/kotlin/com/haroldadmin/cnradapter/CancelTest.kt

@@ -11,7 +11,7 @@ import java.io.IOException
 internal class CancelTest : DescribeSpec({
 
     val mockWebServer = MockWebServer()
-    val factory = CoroutinesNetworkResponseAdapterFactory()
+    val factory = NetworkResponseAdapterFactory()
     val retrofit = Retrofit.Builder()
             .baseUrl(mockWebServer.url("/"))
             .addConverterFactory(StringConverterFactory())