web-dev-qa-db-ja.com

Retrofitで関数を中断するための呼び出しアダプタを作成するにはどうすればよいですか？

このようなネットワーク呼び出しを処理できる改造呼び出しアダプターを作成する必要があります。

_@GET("user")
suspend fun getUser(): MyResponseWrapper<User>
_

Deferredを使用せずにKotlinコルーチンで動作するようにしたい。 Deferredを使用した実装は既に成功しています。これは、次のようなメソッドを処理できます。

_@GET("user")
fun getUser(): Deferred<MyResponseWrapper<User>>
_

しかし、私はその機能を一時停止機能にして、Deferredラッパーを削除する機能を求めています。

中断関数を使用すると、Retrofitは、戻り値の型を囲むCallラッパーがあるかのように機能するため、suspend fun getUser(): Userはfun getUser(): Call<User>として扱われます

私の実装

これを処理しようとする呼び出しアダプタを作成しようとしました。これまでの私の実装は次のとおりです。

工場

_class MyWrapperAdapterFactory : CallAdapter.Factory() {

    override fun get(returnType: Type, annotations: Array<Annotation>, retrofit: Retrofit): CallAdapter<*, *>? {

        val rawType = getRawType(returnType)

        if (rawType == Call::class.Java) {

            returnType as? ParameterizedType
                ?: throw IllegalStateException("$returnType must be parameterized")

            val containerType = getParameterUpperBound(0, returnType)

            if (getRawType(containerType) != MyWrapper::class.Java) {
                return null
            }

            containerType as? ParameterizedType
                ?: throw IllegalStateException("MyWrapper must be parameterized")

            val successBodyType = getParameterUpperBound(0, containerType)
            val errorBodyType = getParameterUpperBound(1, containerType)

            val errorBodyConverter = retrofit.nextResponseBodyConverter<Any>(
                null,
                errorBodyType,
                annotations
            )

            return MyWrapperAdapter<Any, Any>(successBodyType, errorBodyConverter)
        }
        return null
    }
_

アダプター

_class MyWrapperAdapter<T : Any>(
    private val successBodyType: Type
) : CallAdapter<T, MyWrapper<T>> {

    override fun adapt(call: Call<T>): MyWrapper<T> {
        return try {
            call.execute().toMyWrapper<T>()
        } catch (e: IOException) {
            e.toNetworkErrorWrapper()
        }
    }

    override fun responseType(): Type = successBodyType
}
_
_runBlocking {
  val user: MyWrapper<User> = service.getUser()
}
_

この実装を使用するとすべてが期待どおりに機能しますが、ネットワーク呼び出しの結果がuser変数に渡される直前に、次のエラーが発生します。

_Java.lang.ClassCastException: com.myproject.MyWrapper cannot be cast to retrofit2.Call

    at retrofit2.HttpServiceMethod$SuspendForBody.adapt(HttpServiceMethod.Java:185)
    at retrofit2.HttpServiceMethod.invoke(HttpServiceMethod.Java:132)
    at retrofit2.Retrofit$1.invoke(Retrofit.Java:149)
    at com.Sun.proxy.$Proxy6.getText(Unknown Source)
    ...
_

レトロフィットのソースから、ここに_HttpServiceMethod.Java:185_のコードがあります：

_    @Override protected Object adapt(Call<ResponseT> call, Object[] args) {
      call = callAdapter.adapt(call); // ERROR OCCURS HERE

      //noinspection unchecked Checked by reflection inside RequestFactory.
      Continuation<ResponseT> continuation = (Continuation<ResponseT>) args[args.length - 1];
      return isNullable
          ? KotlinExtensions.awaitNullable(call, continuation)
          : KotlinExtensions.await(call, continuation);
    }
_

このエラーの処理方法がわかりません。修正する方法はありますか？

javaandroidkotlinretrofitkotlin-coroutines
19
harold_admin

これは、Resultラッパーへの応答を自動的にラップするアダプターの実際の例です。 GitHubサンプルも available です。

// build.gradle

...
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.6.1'
    implementation 'com.squareup.retrofit2:converter-gson:2.6.1'
    implementation 'com.google.code.gson:gson:2.8.5'
}

// test.kt

...
sealed class Result<out T> {
    data class Success<T>(val data: T?) : Result<T>()
    data class Failure(val statusCode: Int?) : Result<Nothing>()
    object NetworkError : Result<Nothing>()
}

data class Bar(
    @SerializedName("foo")
    val foo: String
)

interface Service {
    @GET("bar")
    suspend fun getBar(): Result<Bar>

    @GET("bars")
    suspend fun getBars(): Result<List<Bar>>
}

abstract class CallDelegate<TIn, TOut>(
    protected val proxy: Call<TIn>
) : Call<TOut> {
    override fun execute(): Response<TOut> = throw NotImplementedError()
    override final fun enqueue(callback: Callback<TOut>) = enqueueImpl(callback)
    override final fun clone(): Call<TOut> = cloneImpl()

    override fun cancel() = proxy.cancel()
    override fun request(): Request = proxy.request()
    override fun isExecuted() = proxy.isExecuted
    override fun isCanceled() = proxy.isCanceled

    abstract fun enqueueImpl(callback: Callback<TOut>)
    abstract fun cloneImpl(): Call<TOut>
}

class ResultCall<T>(proxy: Call<T>) : CallDelegate<T, Result<T>>(proxy) {
    override fun enqueueImpl(callback: Callback<Result<T>>) = proxy.enqueue(object: Callback<T> {
        override fun onResponse(call: Call<T>, response: Response<T>) {
            val code = response.code()
            val result = if (code in 200 until 300) {
                val body = response.body()
                Result.Success(body)
            } else {
                Result.Failure(code)
            }

            callback.onResponse(this@ResultCall, Response.success(result))
        }

        override fun onFailure(call: Call<T>, t: Throwable) {
            val result = if (t is IOException) {
                Result.NetworkError
            } else {
                Result.Failure(null)
            }

            callback.onResponse(this@ResultCall, Response.success(result))
        }
    })

    override fun cloneImpl() = ResultCall(proxy.clone())
}

class ResultAdapter(
    private val type: Type
): CallAdapter<Type, Call<Result<Type>>> {
    override fun responseType() = type
    override fun adapt(call: Call<Type>): Call<Result<Type>> = ResultCall(call)
}

class MyCallAdapterFactory : CallAdapter.Factory() {
    override fun get(
        returnType: Type,
        annotations: Array<Annotation>,
        retrofit: Retrofit
    ) = when (getRawType(returnType)) {
        Call::class.Java -> {
            val callType = getParameterUpperBound(0, returnType as ParameterizedType)
            when (getRawType(callType)) {
                Result::class.Java -> {
                    val resultType = getParameterUpperBound(0, callType as ParameterizedType)
                    ResultAdapter(resultType)
                }
                else -> null
            }
        }
        else -> null
    }
}

/**
 * A Mock interceptor that returns a test data
 */
class MockInterceptor : Interceptor {
    override fun intercept(chain: Interceptor.Chain): okhttp3.Response {
        val response = when (chain.request().url().encodedPath()) {
            "/bar" -> """{"foo":"baz"}"""
            "/bars" -> """[{"foo":"baz1"},{"foo":"baz2"}]"""
            else -> throw Error("unknown request")
        }

        val mediaType = MediaType.parse("application/json")
        val responseBody = ResponseBody.create(mediaType, response)

        return okhttp3.Response.Builder()
            .protocol(Protocol.HTTP_1_0)
            .request(chain.request())
            .code(200)
            .message("")
            .body(responseBody)
            .build()
    }
}

suspend fun test() {
    val mockInterceptor = MockInterceptor()
    val mockClient = OkHttpClient.Builder()
        .addInterceptor(mockInterceptor)
        .build()

    val retrofit = Retrofit.Builder()
        .baseUrl("https://mock.com/")
        .client(mockClient)
        .addCallAdapterFactory(MyCallAdapterFactory())
        .addConverterFactory(GsonConverterFactory.create())
        .build()

    val service = retrofit.create(Service::class.Java)
    val bar = service.getBar()
    val bars = service.getBars()
    ...
}
...
9
Valeriy Katkov

コルーチンで_Retrofit 2.6.0_を使用すると、ラッパーは不要になります。以下のようになります。

_@GET("user")
suspend fun getUser(): User
_

もうMyResponseWrapperは必要ありません。呼び出すと、次のようになります。

_runBlocking {
   val user: User = service.getUser()
}
_

レトロフィットResponseを取得するには、次のようにします。

_@GET("user")
suspend fun getUser(): Response<User>
_

また、MyWrapperAdapterFactoryやMyWrapperAdapterも必要ありません。

これがあなたの質問に答えたことを願っています！

編集 CommonsWare @は、上記のコメントでもこれについて言及しています

編集エラーの処理は次のようになります。

_sealed class ApiResponse<T> {
    companion object {
        fun <T> create(response: Response<T>): ApiResponse<T> {
            return if(response.isSuccessful) {
                val body = response.body()
                // Empty body
                if (body == null || response.code() == 204) {
                    ApiSuccessEmptyResponse()
                } else {
                    ApiSuccessResponse(body)
                }
            } else {
                val msg = response.errorBody()?.string()
                val errorMessage = if(msg.isNullOrEmpty()) {
                    response.message()
                } else {
                    msg
                }
                ApiErrorResponse(errorMessage ?: "Unknown error")
            }
        }
    }
}

class ApiSuccessResponse<T>(val data: T): ApiResponse<T>()
class ApiSuccessEmptyResponse<T>: ApiResponse<T>()
class ApiErrorResponse<T>(val errorMessage: String): ApiResponse<T>()
_

応答をApiResponse.create(response)としてcreateを呼び出すだけで、正しい型が返されるはずです。単なる文字列ではない場合にエラーを解析することにより、ここでもより高度なシナリオを追加できます。

6
Hakem Zaied

この質問は、suspendがRetrofitに導入されたプルリクエストで発生しました。

matejdro：私が見るところによると、このMRは、サスペンド機能を使用するときに、コールアダプターを完全にバイパスします。私は現在、エラーボディの解析を集中化するためにカスタムコールアダプターを使用しています（適切な例外をスローします）。これは、公式のretrofit2サンプルと同様です。これの代わりに、ここの間に注入されるある種のアダプターを取得する可能性はありますか？

これはサポートされていません（まだ？）。

出典： https://github.com/square/retrofit/pull/2886#issuecomment-438936312

エラー処理のために、私はこのようなもののためにAPI呼び出しを呼び出しました：

suspend fun <T : Any> safeApiCall(call: suspend () -> Response<T>): MyWrapper<T> {
    return try {
        val response = call.invoke()
        when (response.code()) {
            // return MyWrapper based on response code
            // MyWrapper is sealed class with subclasses Success and Failure
        }
    } catch (error: Throwable) {
        Failure(error)
    }
}
2
Mikael