Refactor: Retrofit ResultCallAdapter 도입을 통한 API 응답 처리 로직 개선

Author: wjdrjs00

app/src/main/java/com/threegap/bitnagil/di/core/NetworkModule.kt

@@ -10,6 +10,7 @@ import com.threegap.bitnagil.network.Kakao
 import com.threegap.bitnagil.network.NoneAuth
 import com.threegap.bitnagil.network.auth.AuthInterceptor
 import com.threegap.bitnagil.network.auth.TokenAuthenticator
+import com.threegap.bitnagil.network.calladapter.ResultCallAdapterFactory
 import com.threegap.bitnagil.network.token.ReissueService
 import com.threegap.bitnagil.network.token.TokenProvider
 import dagger.Module
@@ -45,7 +46,7 @@ object NetworkModule {
     fun provideJson(): Json =
         Json {
             ignoreUnknownKeys = true
-            prettyPrint = true
+            prettyPrint = BuildConfig.DEBUG
             explicitNulls = false
         }
 
@@ -54,6 +55,10 @@ object NetworkModule {
     fun provideJsonConverter(json: Json): Converter.Factory =
         json.asConverterFactory(APPLICATION_JSON.toMediaType())
 
+    @Provides
+    @Singleton
+    fun provideResultCallAdapterFactory(): ResultCallAdapterFactory = ResultCallAdapterFactory()
+
     @Provides
     @Singleton
     fun provideHttpLoggingInterceptor(): HttpLoggingInterceptor =
@@ -172,10 +177,12 @@ object NetworkModule {
     fun provideAuthRetrofit(
         baseUrl: String,
         converterFactory: Converter.Factory,
+        resultCallAdapterFactory: ResultCallAdapterFactory,
         @Auth okHttpClient: OkHttpClient,
     ): Retrofit = Retrofit.Builder()
         .baseUrl(baseUrl)
         .addConverterFactory(converterFactory)
+        .addCallAdapterFactory(resultCallAdapterFactory)
         .client(okHttpClient)
         .build()
 
@@ -185,10 +192,12 @@ object NetworkModule {
     fun provideNoneAuthRetrofit(
         baseUrl: String,
         converterFactory: Converter.Factory,
+        resultCallAdapterFactory: ResultCallAdapterFactory,
         @NoneAuth okHttpClient: OkHttpClient,
     ): Retrofit = Retrofit.Builder()
         .baseUrl(baseUrl)
         .addConverterFactory(converterFactory)
+        .addCallAdapterFactory(resultCallAdapterFactory)
         .client(okHttpClient)
         .build()
 }

core/network/src/main/java/com/threegap/bitnagil/network/calladapter/ResultCall.kt

@@ -0,0 +1,79 @@
+package com.threegap.bitnagil.network.calladapter
+
+import com.threegap.bitnagil.network.model.BaseResponse
+import com.threegap.bitnagil.network.model.ErrorResponse
+import okhttp3.Request
+import okhttp3.ResponseBody
+import okio.Timeout
+import retrofit2.Call
+import retrofit2.Callback
+import retrofit2.Converter
+import retrofit2.Response
+import kotlin.coroutines.cancellation.CancellationException
+
+class ResultCall<T>(
+    private val delegate: Call<BaseResponse<T>>,
+    private val isUnit: Boolean,
+    private val errorBodyConverter: Converter<ResponseBody, ErrorResponse>,
+) : Call<Result<T>> {
+
+    override fun enqueue(callback: Callback<Result<T>>) {
+        delegate.enqueue(
+            object : Callback<BaseResponse<T>> {
+                override fun onResponse(call: Call<BaseResponse<T>>, response: Response<BaseResponse<T>>) {
+                    val result = if (response.isSuccessful) {
+                        val body = response.body()
+                        when {
+                            isUnit -> {
+                                @Suppress("UNCHECKED_CAST")
+                                Result.success(Unit as T)
+                            }
+
+                            body?.data != null -> Result.success(body.data)
+                            else -> Result.failure(
+                                ApiException(
+                                    code = "EMPTY_DATA: ${response.code()}",
+                                    message = body?.message ?: "Response body or data is null",
+                                ),
+                            )
+                        }
+                    } else {
+                        val errorResponse = parseErrorResponse(response.errorBody())
+                        Result.failure(
+                            ApiException(
+                                code = errorResponse?.code ?: "HTTP_${response.code()}",
+                                message = errorResponse?.message ?: response.message(),
+                            ),
+                        )
+                    }
+                    callback.onResponse(this@ResultCall, Response.success(result))
+                }
+
+                override fun onFailure(call: Call<BaseResponse<T>>, t: Throwable) {
+                    if (t is CancellationException) return
+
+                    callback.onResponse(this@ResultCall, Response.success(Result.failure(t)))
+                }
+            },
+        )
+    }
+
+    private fun parseErrorResponse(errorBody: ResponseBody?): ErrorResponse? =
+        errorBody?.let { body ->
+            try {
+                errorBodyConverter.convert(body)
+            } catch (e: Exception) {
+                null
+            }
+        }
+
+    override fun clone(): Call<Result<T>> = ResultCall(delegate.clone(), isUnit, errorBodyConverter)
+    override fun execute(): Response<Result<T>> = throw UnsupportedOperationException("ResultCall doesn't support execute()")
+    override fun isExecuted(): Boolean = delegate.isExecuted
+    override fun cancel() = delegate.cancel()
+    override fun isCanceled(): Boolean = delegate.isCanceled
+    override fun request(): Request = delegate.request()
+    override fun timeout(): Timeout = delegate.timeout()
+}
+
+class ApiException(val code: String, override val message: String) : Exception(message)

core/network/src/main/java/com/threegap/bitnagil/network/calladapter/ResultCallAdapter.kt

@@ -0,0 +1,53 @@
+package com.threegap.bitnagil.network.calladapter
+
+import com.threegap.bitnagil.network.model.BaseResponse
+import com.threegap.bitnagil.network.model.ErrorResponse
+import okhttp3.ResponseBody
+import retrofit2.Call
+import retrofit2.CallAdapter
+import retrofit2.Converter
+import retrofit2.Retrofit
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+
+class ResultCallAdapterFactory : CallAdapter.Factory() {
+
+    override fun get(
+        returnType: Type,
+        annotations: Array<out Annotation>,
+        retrofit: Retrofit,
+    ): CallAdapter<*, *>? {
+        if (getRawType(returnType) != Call::class.java) return null
+        check(returnType is ParameterizedType) { "Return type must be parameterized as Call<Result<Foo>>" }
+
+        val responseType = getParameterUpperBound(0, returnType)
+
+        if (getRawType(responseType) != Result::class.java) return null
+        check(responseType is ParameterizedType) { "Response must be parameterized as Result<Foo>" }
+
+        val successType = getParameterUpperBound(0, responseType)
+
+        val baseResponseType = object : ParameterizedType {
+            override fun getRawType(): Type = BaseResponse::class.java
+            override fun getOwnerType(): Type? = null
+            override fun getActualTypeArguments(): Array<Type> = arrayOf(successType)
+        }
+
+        val isUnit = getRawType(successType) == Unit::class.java
+
+        val errorBodyConverter: Converter<ResponseBody, ErrorResponse> =
+            retrofit.responseBodyConverter(ErrorResponse::class.java, annotations)
+
+        return ResultCallAdapter<Any>(baseResponseType, isUnit, errorBodyConverter)
+    }
+}
+
+class ResultCallAdapter<T>(
+    private val responseType: Type,
+    private val isUnit: Boolean,
+    private val errorBodyConverter: Converter<ResponseBody, ErrorResponse>,
+) : CallAdapter<BaseResponse<T>, Call<Result<T>>> {
+    override fun responseType(): Type = responseType
+    override fun adapt(call: Call<BaseResponse<T>>): Call<Result<T>> =
+        ResultCall(call, isUnit, errorBodyConverter)
+}