[Feat/call_adpter]call adapter base response 대응 작업

core/common/src/main/java/com/hmh/hamyeonham/common/qualifier/Auth.kt → core/common/src/main/java/com/hmh/hamyeonham/common/qualifier/RetrofitAnnotation.kt

@@ -9,3 +9,7 @@ annotation class Secured
 @Qualifier
 @Retention(AnnotationRetention.BINARY)
 annotation class Unsecured
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class ResultCall

core/network/src/main/java/com/hmh/hamyeonham/core/network/call/ApiException.kt

@@ -0,0 +1,5 @@
+package com.hmh.hamyeonham.core.network.call
+
+import com.hmh.hamyeonham.core.network.model.ErrorResponse
+
+class ApiException(val errorResponse: ErrorResponse) : Exception()

core/network/src/main/java/com/hmh/hamyeonham/core/network/call/ResultCall.kt

@@ -0,0 +1,119 @@
+package com.hmh.hamyeonham.core.network.call
+
+import com.hmh.hamyeonham.core.network.model.BaseResponse
+import com.hmh.hamyeonham.core.network.model.ErrorResponse
+import okhttp3.Request
+import okio.IOException
+import okio.Timeout
+import retrofit2.Call
+import retrofit2.Callback
+import retrofit2.HttpException
+import retrofit2.Response
+import retrofit2.Retrofit
+import timber.log.Timber
+
+class ResultCall<T>(
+    private val call: Call<T>,
+    private val retrofit: Retrofit,
+) : Call<Result<T>> {
+
+    override fun enqueue(callback: Callback<Result<T>>) {
+        call.enqueue(object : Callback<T> {
+            override fun onResponse(
+                call: Call<T>,
+                response: Response<T>
+            ) {
+                val result = parseBaseResponse(response)
+                callback.onResponse(this@ResultCall, Response.success(response.code(), result))
+            }
+
+            override fun onFailure(call: Call<T>, t: Throwable) {
+                val errorMessage = when (t) {
+                    is IOException -> "네트워크 연결이 불안정합니다. 다시 시도해주세요."
+                    is HttpException -> "${t.code()} : 서버 통신 중 문제가 발생했습니다. 다시 시도해주세요."
+                    else -> t.message ?: "알 수 없는 오류가 발생했습니다. 다시 시도해주세요."
+                }
+
+                callback.onResponse(
+                    this@ResultCall,
+                    Response.success(Result.failure(RuntimeException(errorMessage)))
+                )
+
+                Timber.tag("ResultCall - onFailure").e("onFailure: $errorMessage")
+            }
+        })
+    }
+
+    override fun execute(): Response<Result<T>> {
+        val response = call.execute()
+        return Response.success(parseBaseResponse(response))
+    }
+
+    /**
+     * BaseResponse<T>를 안전하게 처리하여 Result<T>로 변환
+     */
+    private fun parseBaseResponse(response: Response<T>): Result<T> {
+        return if (response.isSuccessful) {
+            val baseResponse = response.body() as? BaseResponse<T> ?: return Result.failure(
+                ApiException(
+                    ErrorResponse(
+                        700,
+                        "Response body is null or not in expected BaseResponse format"
+                    )
+                )
+            )
+            try {
+                Result.success(baseResponse.data)
+            } catch (e: Exception) {
+                Result.failure(
+                    ApiException(
+                        ErrorResponse(
+                            700,
+                            "Response body conversion failed: ${e.message}"
+                        )
+                    )
+                )
+            }
+        } else {
+            val errorResponse = parseErrorResponse(response)
+            Result.failure(ApiException(errorResponse))
+        }
+    }
+
+
+    /**
+     * Retrofit을 사용해 errorBody()를 파싱하여 ErrorResponse로 변환
+     */
+    private fun parseErrorResponse(response: Response<T>): ErrorResponse {
+        return try {
+            retrofit.responseBodyConverter<ErrorResponse>(
+                ErrorResponse::class.java,
+                ErrorResponse::class.java.annotations
+            ).convert(response.errorBody()!!) ?: getBodyNullErrorResponse(response)
+        } catch (e: Exception) {
+            getBodyNullErrorResponse(response)
+        }
+    }
+
+    /**
+     * 응답 Body가 null인 경우 기본 ErrorResponse 반환
+     */
+    private fun getBodyNullErrorResponse(response: Response<T>) = ErrorResponse(
+        status = response.code(),
+        message = "response body is null"
+    )
+
+    override fun clone(): Call<Result<T>> = ResultCall(call.clone(), retrofit)
+
+    override fun isExecuted(): Boolean = call.isExecuted
+
+    override fun cancel() {
+        call.cancel()
+    }
+
+    override fun isCanceled(): Boolean = call.isCanceled
+
+    override fun request(): Request = call.request()
+
+    override fun timeout(): Timeout = call.timeout()
+}

core/network/src/main/java/com/hmh/hamyeonham/core/network/call/ResultCallAdapterFactory.kt

@@ -0,0 +1,51 @@
+package com.hmh.hamyeonham.core.network.call
+
+import com.hmh.hamyeonham.core.network.model.BaseResponse
+import retrofit2.Call
+import retrofit2.CallAdapter
+import retrofit2.Retrofit
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+import javax.inject.Inject
+
+class ResultCallAdapterFactory @Inject constructor() : CallAdapter.Factory() {
+
+    override fun get(
+        returnType: Type,
+        annotations: Array<out Annotation>,
+        retrofit: Retrofit
+    ): CallAdapter<*, *>? {
+        // 서비스 인터페이스의 반환 타입이 Call<Result<*>>여야 함
+        if (getRawType(returnType) != Call::class.java || returnType !is ParameterizedType) {
+            return null
+        }
+
+        // 내부의 Result<T> 형태여야 함
+        val resultType = getParameterUpperBound(0, returnType)
+        if (getRawType(resultType) != Result::class.java || resultType !is ParameterizedType) {
+            return null
+        }
+
+        // Result<T>에서 T를 추출
+        val innerType = getParameterUpperBound(0, resultType)
+
+        return object : CallAdapter<Any, Call<Result<*>>> {
+            override fun responseType(): Type {
+                // Retrofit에게 BaseResponse<T>로 변환하도록 타입을 전달합니다.
+                return newParameterizedType(BaseResponse::class.java, innerType)
+            }
+
+            override fun adapt(call: Call<Any>): Call<Result<*>> {
+                return ResultCall(call, retrofit) as Call<Result<*>>
+            }
+        }
+    }
+
+    private fun newParameterizedType(rawType: Type, vararg typeArguments: Type): ParameterizedType {
+        return object : ParameterizedType {
+            override fun getRawType(): Type = rawType
+            override fun getOwnerType(): Type? = null
+            override fun getActualTypeArguments(): Array<out Type> = typeArguments
+        }
+    }
+}

core/network/src/main/java/com/hmh/hamyeonham/core/network/di/MainModule.kt

@@ -1,6 +1,6 @@
 package com.hmh.hamyeonham.core.network.di
 
-import com.hmh.hamyeonham.common.qualifier.Secured
+import com.hmh.hamyeonham.common.qualifier.ResultCall
 import com.hmh.hamyeonham.core.network.main.MainService
 import dagger.Module
 import dagger.Provides
@@ -15,5 +15,5 @@ import javax.inject.Singleton
 object MainModule {
     @Provides
     @Singleton
-    fun provideMainService(@Secured retrofit: Retrofit): MainService = retrofit.create()
+    fun provideMainService(@ResultCall retrofit: Retrofit): MainService = retrofit.create()
 }

core/network/src/main/java/com/hmh/hamyeonham/core/network/di/NetModule.kt

@@ -4,12 +4,14 @@ import com.hmh.hamyeonham.common.BuildConfig
 import com.hmh.hamyeonham.common.qualifier.Authenticated
 import com.hmh.hamyeonham.common.qualifier.Header
 import com.hmh.hamyeonham.common.qualifier.Log
+import com.hmh.hamyeonham.common.qualifier.ResultCall
 import com.hmh.hamyeonham.common.qualifier.Secured
 import com.hmh.hamyeonham.common.qualifier.Unsecured
 import com.hmh.hamyeonham.core.network.auth.authenticator.AuthenticatorUtil
 import com.hmh.hamyeonham.core.network.auth.authenticator.HMHAuthenticator
 import com.hmh.hamyeonham.core.network.auth.interceptor.AuthInterceptor
 import com.hmh.hamyeonham.core.network.auth.interceptor.HeaderInterceptor
+import com.hmh.hamyeonham.core.network.call.ResultCallAdapterFactory
 import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
 import dagger.Binds
 import dagger.Module
@@ -117,10 +119,26 @@ object NetModule {
     fun provideRetrofitNotNeededAuth(
         @Unsecured client: OkHttpClient,
         converterFactory: Converter.Factory,
+        resultCallAdapterFactory: ResultCallAdapterFactory,
     ): Retrofit = Retrofit.Builder()
         .baseUrl(HMHBaseUrl)
         .client(client)
         .addConverterFactory(converterFactory)
+        .addCallAdapterFactory(resultCallAdapterFactory)
+        .build()
+
+    @Singleton
+    @Provides
+    @ResultCall
+    fun provideResultCallRetrofit(
+        @Secured client: OkHttpClient,
+        converterFactory: Converter.Factory,
+        resultCallAdapterFactory: ResultCallAdapterFactory,
+    ): Retrofit = Retrofit.Builder()
+        .baseUrl(HMHBaseUrl)
+        .client(client)
+        .addConverterFactory(converterFactory)
+        .addCallAdapterFactory(resultCallAdapterFactory)
         .build()
 
     @Module

core/network/src/main/java/com/hmh/hamyeonham/core/network/main/MainService.kt

@@ -1,10 +1,9 @@
 package com.hmh.hamyeonham.core.network.main
 
 import com.hmh.hamyeonham.core.network.main.model.BannerResponse
-import com.hmh.hamyeonham.core.network.model.BaseResponse
 import retrofit2.http.GET
 
 interface MainService {
     @GET("api/v2/banner")
-    suspend fun getBanner(): BaseResponse<BannerResponse>
+    suspend fun getBanner(): Result<BannerResponse>
 }

core/network/src/main/java/com/hmh/hamyeonham/core/network/model/ErrorResponse.kt

@@ -0,0 +1,12 @@
+package com.hmh.hamyeonham.core.network.model
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ErrorResponse(
+    @SerialName("status")
+    val status: Int,
+    @SerialName("message")
+    val message: String,
+)

data/main/src/main/java/com/hmh/hamyeonham/data/main/DefaultMainRepository.kt

@@ -1,6 +1,7 @@
 package com.hmh.hamyeonham.data.main
 
 import com.hmh.hamyeonham.core.network.main.MainService
+import com.hmh.hamyeonham.core.network.main.model.BannerResponse
 import com.hmh.hamyeonham.domain.main.MainRepository
 import com.hmh.hamyeonham.domain.main.banner.model.Banner
 import com.hmh.hamyeonham.login.mapper.toBanner
@@ -10,8 +11,6 @@ class DefaultMainRepository @Inject constructor(
     private val mainService: MainService
 ) : MainRepository {
     override suspend fun getBanner(): Result<Banner> {
-        return runCatching {
-            mainService.getBanner().data.toBanner()
-        }
+        return mainService.getBanner().mapCatching(BannerResponse::toBanner)
     }
 }