Upgrade, Live Data adapter, make the response class wrapper common?

Question

I use an adapter to connect LiveData for modification, adapted from a Google sample

public interface ApiService {
    @GET("?schema=1.2&form=cjson&byCategories=liveChannels&range=1-500&count=true")
    LiveData<ApiResponse<Page<Media>>> getChannels();
}

I need to use different endpoints, so I want to make a generic ApiResponse. ApiResponse will be an interface or abstract and has different options from it for all of these endpoints; I do not want to write different LiveData extensions for each class that extends ApiResponse.

I want to do something like:

RetrofitLiveData<R, E extends ApiResponse<R>> extends LiveData<E<R>>

(I know the previous code does not compile, this is just an example of what I want)

and then in the modified interface I can:

LiveData<Endpoint1ApiResponse<Endpoint1Data>>
LiveData<Endpoint2ApiResponse<Endpoint2Data>>
LiveData<Endpoint3ApiResponse<Endpoint3Data>>


public class LiveDataCallAdapterFactory extends CallAdapter.Factory {

    @Override
    public CallAdapter<?, ?> get(@NonNull Type returnType, @NonNull Annotation[] annotations,
                                 @NonNull Retrofit retrofit) {
        if (getRawType(returnType) != LiveData.class) {
            return null;
        }
        Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
        Class<?> rawObservableType = getRawType(observableType);
        if (rawObservableType != ApiResponse.class) {
            throw new IllegalArgumentException("type must be a resource");
        }
        if (! (observableType instanceof ParameterizedType)) {
            throw new IllegalArgumentException("resource must be parameterized");
        }
        Type bodyType = getParameterUpperBound(0, (ParameterizedType) observableType);
        return new LiveDataCallAdapter<>(bodyType);
    }
}

public class LiveDataCallAdapter<R> implements CallAdapter<R, LiveData<ApiResponse<R>>> {
    private final Type responseType;

    public LiveDataCallAdapter(Type responseType) {
        this.responseType = responseType;
    }

    @Override
    public Type responseType() {
        return responseType;
    }

    @Override
    public LiveData<ApiResponse<R>> adapt(@NonNull Call<R> call) {
        return new RetrofitLiveData<R>(call);
    }
}

public class RetrofitLiveData<R> extends LiveData<ApiResponse<R>> {
    private final Call<R> call;

    public RetrofitLiveData(Call<R> call) {
        this.call = call;
    }

    @Override
    protected void onActive() {
        if (!call.isCanceled() && !call.isExecuted()) {
            call.enqueue(callback);
        }
    }

    private final Callback<R> callback = new Callback<R>() {
        @Override
        public void onResponse(@NonNull Call<R> call, @NonNull Response<R> response) {
            postValue(new ApiResponse<>(response));
        }

        @Override
        public void onFailure(@NonNull Call<R> call, @NonNull Throwable t) {
            postValue(new ApiResponse<>(t));
        }
    };

    public void cancel() {
        if (!call.isCanceled()) {
            call.cancel();
        }
    }
}

public class ApiResponse<T> {
    public final int code;
    @Nullable
    public final T body;
    @Nullable
    public final String errorMessage;

    public ApiResponse(Throwable error) {
        code = 500;
        body = null;
        errorMessage = error.getMessage();
    }

    public ApiResponse(Response<T> response) {
        // .......... not important here
    }

    public boolean isSuccessful() {
        return code >= 200 && code < 300;
    }
}

Answer 1

You can use these classes to achieve your goal.

1- liveDataWrapper CallAdapterFactory. , NetworkData .

import android.os.Handler
import android.os.Looper
import androidx.lifecycle.MutableLiveData
import retrofit2.HttpException


    class NetworkLiveData<T> : MutableLiveData<NetworkLiveData.NetworkData<T?>>() {

        private lateinit var observer: NetworkData<T?>.() -> Unit

        internal fun onSuccessResponse(body: T?) {
            val result = NetworkData.Success(body)
            postValue(result)
        }

        fun observeForever(f: NetworkData<T?>.() -> Unit) {
            observer = f
            super.observeForever(f)
        }

        internal fun onResponseHttpException(httpException: HttpException) {
            val result = NetworkData.ErrorResponse<T?>(httpException)
            postValue(result)
        }

        internal fun onFailedRequest(t: Throwable) {
            val result = NetworkData.ErrorRequest<T?>(t)
            postValue(result)
        }

        fun onFinish() {
            Handler(Looper.getMainLooper()).post {
                this.removeObserver(observer)
            }
        }

        sealed class NetworkData<T> {
            data class Success<T>(val value: T) : NetworkData<T>()
            data class ErrorResponse<T>(val httpException: HttpException) : NetworkData<T>()
            data class ErrorRequest<T>(val t: Throwable) : NetworkData<T>()

            fun onSuccess(f: (responseBody: T) -> Unit) {
                if (this is Success) {
                    f.invoke(value)
                }
            }

            fun onHttpException(f: (code: Int, message: String) -> Unit) {
                if (this is ErrorResponse) {
                    f.invoke(httpException.code(), httpException.message())
                }
            }

            fun onConnectionFailed(f: (t: Throwable) -> Unit) {
                if (this is ErrorRequest) {
                    f.invoke(t)
                }
            }
        }
    }

2- CallAdapterFactory LiveData

import retrofit2.*
import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type


class LiveDataCallAdapterFactory private constructor() : CallAdapter.Factory() {
    companion object {
        operator fun invoke() = LiveDataCallAdapterFactory()
    }

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

        if (getRawType(returnType) != NetworkLiveData::class.java) {
            return null
        }

        if (returnType !is ParameterizedType) {
            throw IllegalStateException(
                "must be parameterized"
            )
        }
        val responseType = getParameterUpperBound(0, returnType)
        return BodyCallAdapter<Any>(responseType)
    }


    private class BodyCallAdapter<T>(
        private val responseType: Type
    ) : CallAdapter<T, NetworkLiveData<T>> {

        override fun responseType() = responseType

        override fun adapt(call: Call<T>): NetworkLiveData<T> {
            val liveData = NetworkLiveData<T>()

            call.enqueue(object : Callback<T> {
                override fun onFailure(call: Call<T>, t: Throwable) {
                    liveData.onFailedRequest(t)
                    liveData.onFinish()
                }

                override fun onResponse(call: Call<T>, response: Response<T>) {
                    if (response.isSuccessful) {
                        liveData.onSuccessResponse(response.body())
                    } else {
                        liveData.onResponseHttpException(HttpException(response))
                    }
                    liveData.onFinish()
                }
            })
            return liveData
        }
    }
}

github.

Answer 2

CallAdapterFactory : liveDataCallAdapter

CallAdapterFactory

liveData