Android CallAdapter中的类型推断失败

我修改了Google示例中的LiveDataCallAdapter，并创建了自己的CallAdapter，它返回一个GenericApiResponse

错误出现在这一行（在onFailure中）：

GenericApiResponse.create（throwable）

错误：类型推断失败：没有足够的信息来推断fun create中的参数T（错误：Throwable）：ApiErrorResponse请显式指定它

如何从onResponse/onFailure中获取对象，以便将其返回给adapt方法？：）

LiveDataCallAdapter

import androidx.lifecycle.LiveData
import retrofit2.Call
import retrofit2.CallAdapter
import retrofit2.Callback
import retrofit2.Response
import java.lang.reflect.Type
import java.util.concurrent.atomic.AtomicBoolean

class LiveDataCallAdapter<R>(private val responseType: Type) :
    CallAdapter<R, LiveData<GenericApiResponse<R>>> {

    override fun responseType() = responseType

    override fun adapt(call: Call<R>): LiveData<GenericApiResponse<R>> {
        return object : LiveData<GenericApiResponse<R>>() {
            private var started = AtomicBoolean(false)
            override fun onActive() {
                super.onActive()
                if (started.compareAndSet(false, true)) {
                    call.enqueue(object : Callback<R> {
                        override fun onResponse(call: Call<R>, response: Response<R>) {
                            postValue(GenericApiResponse.create(response))
                        }

                        override fun onFailure(call: Call<R>, throwable: Throwable) {
                            postValue(GenericApiResponse.create(throwable))
                        }
                    })
                }
            }
        }
    }
}

import NetworkResponseCall
import androidx.lifecycle.LiveData
import com.example.mvi.util.GenericApiResponse
import okhttp3.ResponseBody
import retrofit2.*
import java.lang.reflect.Type
import java.util.concurrent.atomic.AtomicBoolean

class NetworkAdapter<R>(private val responseType: Type) :
    CallAdapter<R, GenericApiResponse<R>> {

    override fun responseType() = responseType

    override fun adapt(call: Call<R>): GenericApiResponse<R> {
        call.enqueue(object : Callback<R> {
            override fun onResponse(call: Call<R>, response: Response<R>) {
                GenericApiResponse.create(response)
            }

            override fun onFailure(call: Call<R>, throwable: Throwable) {
                GenericApiResponse.create(throwable)
            }
        })
    }
}

导入androidx.lifecycle.LiveData
2.致电
导入2.0适配器
导入2.回调
2.回应
导入java.lang.reflect.Type
导入java.util.concurrent.AtomicBoolean
类LiveDataCallAdapter（专用val响应类型：类型）：
呼叫适配器{
重写fun responseType（）=responseType
覆盖乐趣适应（调用：调用）：LiveData{
返回对象：LiveData（）{
private var start=AtomicBoolean（false）
override-onActive（）{
super.onActive（）
if（启动。比较数据集（false，true））{
排队（对象：Callback{
覆盖fun onResponse（调用：调用，响应：响应）{
postValue（GenericApiResponse.create（response））
}
覆盖失败时的乐趣（调用：调用，可丢弃：可丢弃）{
postValue（GenericApiResponse.create（可丢弃））
}
})
}
}
}
}
}

我修改过的呼叫适配器

import androidx.lifecycle.LiveData
import retrofit2.Call
import retrofit2.CallAdapter
import retrofit2.Callback
import retrofit2.Response
import java.lang.reflect.Type
import java.util.concurrent.atomic.AtomicBoolean

class LiveDataCallAdapter<R>(private val responseType: Type) :
    CallAdapter<R, LiveData<GenericApiResponse<R>>> {

    override fun responseType() = responseType

    override fun adapt(call: Call<R>): LiveData<GenericApiResponse<R>> {
        return object : LiveData<GenericApiResponse<R>>() {
            private var started = AtomicBoolean(false)
            override fun onActive() {
                super.onActive()
                if (started.compareAndSet(false, true)) {
                    call.enqueue(object : Callback<R> {
                        override fun onResponse(call: Call<R>, response: Response<R>) {
                            postValue(GenericApiResponse.create(response))
                        }

                        override fun onFailure(call: Call<R>, throwable: Throwable) {
                            postValue(GenericApiResponse.create(throwable))
                        }
                    })
                }
            }
        }
    }
}

import NetworkResponseCall
import androidx.lifecycle.LiveData
import com.example.mvi.util.GenericApiResponse
import okhttp3.ResponseBody
import retrofit2.*
import java.lang.reflect.Type
import java.util.concurrent.atomic.AtomicBoolean

class NetworkAdapter<R>(private val responseType: Type) :
    CallAdapter<R, GenericApiResponse<R>> {

    override fun responseType() = responseType

    override fun adapt(call: Call<R>): GenericApiResponse<R> {
        call.enqueue(object : Callback<R> {
            override fun onResponse(call: Call<R>, response: Response<R>) {
                GenericApiResponse.create(response)
            }

            override fun onFailure(call: Call<R>, throwable: Throwable) {
                GenericApiResponse.create(throwable)
            }
        })
    }
}

导入网络响应调用
导入androidx.lifecycle.LiveData
导入com.example.mvi.util.GenericApiResponse
导入okhttp3.responsebook
进口改装2*
导入java.lang.reflect.Type
导入java.util.concurrent.AtomicBoolean
类NetworkAdapter（专用val响应类型：类型）：
呼叫适配器{
重写fun responseType（）=responseType
覆盖乐趣适应（调用：调用）：一般响应{
排队（对象：Callback{
覆盖fun onResponse（调用：调用，响应：响应）{
GenericApiResponse.create（响应）
}
覆盖失败时的乐趣（调用：调用，可丢弃：可丢弃）{
GenericApiResponse.create（可丢弃）
}
})
}
}

我的一般回答是：

package com.example.mvi.util

import android.util.Log
import retrofit2.Response

/**
 * Copied from Architecture components google sample:
 * https://github.com/googlesamples/android-architecture-components/blob/master/GithubBrowserSample/app/src/main/java/com/android/example/github/api/ApiResponse.kt
 */
@Suppress("unused") // T is used in extending classes
sealed class GenericApiResponse<T> {

    companion object {
        private val TAG: String = "AppDebug"


        fun <T> create(error: Throwable): ApiErrorResponse<T> {
            return ApiErrorResponse(error.message ?: "unknown error")
        }

        fun <T> create(response: Response<T>): GenericApiResponse<T> {

            Log.d(TAG, "GenericApiResponse: response: ${response}")
            Log.d(TAG, "GenericApiResponse: raw: ${response.raw()}")
            Log.d(TAG, "GenericApiResponse: headers: ${response.headers()}")
            Log.d(TAG, "GenericApiResponse: message: ${response.message()}")

            if(response.isSuccessful){
                val body = response.body()
                if (body == null || response.code() == 204) {
                    return ApiEmptyResponse()
                }
                else if(response.code() == 401){
                    return ApiErrorResponse("401 Unauthorized. Token may be invalid.")
                }
                else {
                    return ApiSuccessResponse(body = body)
                }
            }
            else{
                val msg = response.errorBody()?.string()
                val errorMsg = if (msg.isNullOrEmpty()) {
                    response.message()
                } else {
                    msg
                }
                return ApiErrorResponse(errorMsg ?: "unknown error")
            }
        }
    }
}

/**
 * separate class for HTTP 204 responses so that we can make ApiSuccessResponse's body non-null.
 */
class ApiEmptyResponse<T> : GenericApiResponse<T>()

data class ApiSuccessResponse<T>(val body: T) : GenericApiResponse<T>()

data class ApiErrorResponse<T>(val errorMessage: String) : GenericApiResponse<T>()

package com.example.mvi.util
导入android.util.Log
2.回应
/**
*复制自架构组件google示例：
* https://github.com/googlesamples/android-architecture-components/blob/master/GithubBrowserSample/app/src/main/java/com/android/example/github/api/ApiResponse.kt
*/
@Suppress（“unused”）//T用于扩展类
密封类一般响应{
伴星{
private val标记：String=“AppDebug”
乐趣创建（错误：可丢弃）：ApiErrorResponse{
返回APIRErrorResponse（错误消息？：“未知错误”）
}
有趣的创造（回应：回应）：一般的回应{
Log.d（标记“GenericApiResponse:response:${response}”）
Log.d（标记，“GenericApiResponse:raw:${response.raw（）}”）
Log.d（标记，“GenericApiResponse:headers:${response.headers（）}”）
Log.d（标记，“GenericApiResponse:message:${response.message（）}”）
if（response.issucessful）{
val body=response.body（）
if（body==null | | response.code（）==204）{
返回apieptyResponse（）
}
else if（response.code（）==401）{
返回APIRErrorResponse（“401未经授权。令牌可能无效”）
}
否则{
返回APIssuccessResponse（正文=正文）
}
}
否则{
val msg=response.errorBody（）？.string（）
val errorMsg=if（msg.isNullOrEmpty（））{
response.message（）
}否则{
味精
}
返回ApiErrorResponse（errorMsg？：“未知错误”）
}
}
}
}
/**
*为HTTP 204响应单独创建一个类，这样我们就可以使APIssuccessResponse的主体非空。
*/
类APIPEmptyResponse:GenericApiResponse（）
数据类APIssuccessResponse（val body:T）：GenericApiResponse（）
数据类ApiErrorResponse（val errorMessage:String）：GenericApiResponse（）