FlowCallAdapter.kt

class FlowResultCallAdapter<R>(
    private val responseType: Type,
    private val annotations: Array<out Annotation>
) : CallAdapter<R, Flow<Result<R>>> {
    override fun adapt(call: Call<R>): Flow<Result<R>> {
        return flow {
            emit(
                suspendCancellableCoroutine { continuation ->
                    call.clone().enqueue(object : Callback<R> {

                        override fun onResponse(call: Call<R>, response: Response<R>) {
                            val statusCode = response.code()
                            continuation.resume(
                                if (response.isSuccessful) {
                                    val body = response.body()
                                    if (body == null || statusCode == 204) {
                                        Result.Empty()
                                    } else {
                                        Result.Success(
                                            data = body,
                                            statusCode = statusCode
                                        )
                                    }
                                } else {
                                    val errorResponse = parseError(
                                        statusCode = statusCode,
                                        responseBody = response.errorBody(),
                                        annotations = annotations
                                    )
                                    Result.Error(
                                        message = response.message(),
                                        statusCode = statusCode,
                                        errorResponse = errorResponse
                                    )
                                }
                            )
                        }

                        override fun onFailure(call: Call<R>, throwable: Throwable) {
                            continuation.resume(Result.Error(throwable))
                        }
                    })
                    continuation.invokeOnCancellation { call.cancel() }
                }
            )
        }
    }

    override fun responseType() = responseType
}