Add support for Kotlin's Result

Co-authored-by: tomridder <[email protected]>

retrofit/kotlin-test/build.gradle

@@ -3,6 +3,7 @@ apply plugin: 'org.jetbrains.kotlin.jvm'
 dependencies {
  testImplementation projects.retrofit
  testImplementation projects.retrofit.testHelpers
+ testImplementation projects.retrofitConverters.gson
  testImplementation libs.junit
  testImplementation libs.assertj
  testImplementation libs.mockwebserver

retrofit/kotlin-test/src/test/java/retrofit2/KotlinSuspendTest.kt

@@ -31,6 +31,7 @@ import org.junit.Assert.fail
 import org.junit.Ignore
 import org.junit.Rule
 import org.junit.Test
+import retrofit2.converter.gson.GsonConverterFactory
 import retrofit2.helpers.ToStringConverterFactory
 import retrofit2.http.GET
 import retrofit2.http.HEAD
@@ -49,6 +50,8 @@ class KotlinSuspendTest {
  @GET("/") suspend fun response(): Response<String>
  @GET("/") suspend fun unit()
  @HEAD("/") suspend fun headUnit()
+ @GET("user") suspend fun getUser(): Result<User>
+ @HEAD("user") suspend fun headUser(): Result<Unit>
 
  @GET("/{a}/{b}/{c}")
  suspend fun params(
@@ -60,6 +63,8 @@ class KotlinSuspendTest {
  @GET("/") suspend fun bodyWithCallType(): Call<String>
  }
 
+ data class User(val id: Int, val name: String, val email: String)
+
  @Test fun body() {
  val retrofit = Retrofit.Builder()
  .baseUrl(server.url("/"))
@@ -374,6 +379,56 @@ class KotlinSuspendTest {
  }
  }
 
+ @Test fun returnResultType() = runBlocking {
+ val responseBody = """
+ {
+ "id": 1,
+ "name": "John Doe",
+ "email": "[email protected]"
+ }
+ """.trimIndent()
+ val retrofit = Retrofit.Builder()
+ .baseUrl(server.url("/"))
+ .addCallAdapterFactory(ResultCallAdapterFactory.create())
+ .addConverterFactory(GsonConverterFactory.create())
+ .build()
+ val service = retrofit.create(Service::class.java)
+
+ // Successful response with body.
+ server.enqueue(MockResponse().setBody(responseBody))
+ service.getUser().let { result ->
+ assertThat(result.isSuccess).isTrue()
+ assertThat(result.getOrThrow().id).isEqualTo(1)
+ assertThat(result.getOrThrow().name).isEqualTo("John Doe")
+ assertThat(result.getOrThrow().email).isEqualTo("[email protected]")
+ }
+
+ // Successful response without body.
+ server.enqueue(MockResponse())
+ service.headUser().let { result ->
+ assertThat(result.isSuccess).isTrue()
+ assertThat(result.getOrThrow()).isEqualTo(Unit)
+ }
+
+ // Error response without body.
+ server.enqueue(MockResponse().setResponseCode(404))
+ service.getUser().let { result ->
+ assertThat(result.isFailure).isTrue()
+ assertThat(result.exceptionOrNull())
+ .isInstanceOf(HttpException::class.java)
+ .hasMessage("HTTP 404 Client Error")
+ }
+
+ // Network error.
+ server.shutdown()
+ service.getUser().let { result ->
+ assertThat(result.isFailure).isTrue()
+ assertThat(result.exceptionOrNull()).isInstanceOf(IOException::class.java)
+ }
+
+ Unit // Return type of runBlocking is Unit.
+ }
+
  @Suppress("EXPERIMENTAL_OVERRIDE")
  private object DirectUnconfinedDispatcher : CoroutineDispatcher() {
  override fun isDispatchNeeded(context: CoroutineContext): Boolean = false

retrofit/src/main/java/retrofit2/HttpServiceMethod.java

@@ -23,6 +23,7 @@
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import javax.annotation.Nullable;
+import kotlin.Result;
 import kotlin.Unit;
 import kotlin.coroutines.Continuation;
 import okhttp3.ResponseBody;
@@ -42,7 +43,7 @@ static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotatio
  boolean continuationIsUnit = false;
 
  Annotation[] annotations = method.getAnnotations();
- Type adapterType;
+ final Type adapterType;
  if (isKotlinSuspendFunction) {
  Type[] parameterTypes = method.getGenericParameterTypes();
  Type responseType =
@@ -52,22 +53,28 @@ static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotatio
  // Unwrap the actual body type from Response<T>.
  responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);
  continuationWantsResponse = true;
+ adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
  } else {
- if (getRawType(responseType) == Call.class) {
+ Class<?> rawType = getRawType(responseType);
+ if (rawType == Call.class) {
  throw methodError(
  method,
  "Suspend functions should not return Call, as they already execute asynchronously.\n" +
  "Change its return type to %s", Utils.getParameterUpperBound(0, (ParameterizedType) responseType));
  }
 
+ if (rawType == Result.class) {
+ adapterType = responseType;
+ } else {
+ adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
+ }
+
  continuationIsUnit = Utils.isUnit(responseType);
  // TODO figure out if type is nullable or not
  // Metadata metadata = method.getDeclaringClass().getAnnotation(Metadata.class)
  // Find the entry for method
  // Determine if return type is nullable or not
  }
-
- adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
  annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
  } else {
  adapterType = method.getGenericReturnType();

retrofit/src/main/java/retrofit2/ResultCallAdapterFactory.kt

@@ -0,0 +1,83 @@
+package retrofit2
+
+import java.io.IOException
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+import okhttp3.Request
+import okio.Timeout
+
+class ResultCallAdapterFactory private constructor() : CallAdapter.Factory() {
+ override fun get(
+ returnType: Type,
+ annotations: Array<Annotation>,
+ retrofit: Retrofit
+ ): CallAdapter<*, *>? {
+ if (getRawType(returnType) != Result::class.java) return null
+
+ check(returnType is ParameterizedType) {
+ "Result must have a generic type (e.g., Result<T>)"
+ }
+
+ return ResultCallAdapter<Any>(getParameterUpperBound(0, returnType))
+ }
+
+ companion object {
+ @JvmStatic
+ fun create(): CallAdapter.Factory = ResultCallAdapterFactory()
+ }
+}
+
+class ResultCallAdapter<T>(
+ private val responseType: Type
+) : CallAdapter<T, Call<Result<T>>> {
+
+ override fun responseType(): Type = responseType
+
+ override fun adapt(call: Call<T>): Call<Result<T>> = ResultCall(call)
+}
+
+class ResultCall<T>(private val delegate: Call<T>) : Call<Result<T>> {
+
+ override fun enqueue(callback: Callback<Result<T>>) {
+ delegate.enqueue(object : Callback<T> {
+ override fun onResponse(call: Call<T>, response: Response<T>) {
+ val result = runCatching {
+ if (response.isSuccessful) {
+ response.body() ?: error("Response $response body is null.")
+ } else {
+ throw HttpException(response)
+ }
+ }
+ callback.onResponse(this@ResultCall, Response.success(result))
+ }
+
+ override fun onFailure(call: Call<T>, t: Throwable) {
+ callback.onResponse(this@ResultCall, Response.success(Result.failure(t)))
+ }
+ })
+ }
+
+ override fun execute(): Response<Result<T>> {
+ val result = runCatching {
+ val response = delegate.execute()
+ if (response.isSuccessful) {
+ response.body() ?: error("Response $response body is null.")
+ } else {
+ throw IOException("Unexpected error: ${response.errorBody()?.string()}")
+ }
+ }
+ return Response.success(result)
+ }
+
+ override fun isExecuted(): Boolean = delegate.isExecuted
+
+ override fun clone(): ResultCall<T> = ResultCall(delegate.clone())
+
+ override fun isCanceled(): Boolean = delegate.isCanceled
+
+ override fun cancel(): Unit = delegate.cancel()
+
+ override fun request(): Request = delegate.request()
+
+ override fun timeout(): Timeout = delegate.timeout()
+}