Android存储库模式：如何将额外数据传递给Fragment / Activity

Question

I read this guide: https://developer.android.com/jetpack/docs/guide and try to use repository pattern in this case:

app via Retrofit lib make GET request to server /get/user and response from server may be like this (with status 200):

 {
    "user": {"name" : "Jack", "id": "99"},
    "status": true
 }

or like this (with status 200):

{ "status": false, "message": "Some error here"}

or, 500 error, for example.

My UserFragment should show dialog, dependent on server response: if all is ok - ok message, if status false - error message from api response, if 500 - other error message.

My POJO model looks like this:

public class User {
  private String id;
  private String name;
  // getters and setters omitted
}


public class ApiResponse {
  private User user;
  private Boolean status;
  private String message;
  // getters and setters omitted
}

How I should deal with it in repository pattern?

1. Does my repository object should return User to ViewModel? If yes - how my ViewModel know about status and message fields of api response?
2. Or my repository object should return Directly ApiResponse to ViewModel, and ViewModel got status, message and user from it and pass them to Fragment? But what if I want cache user to database? Does we need store all ApiResponse to database or we need Store only User?
3. Or something else...?

I prefer 1, because It's more clear for me, but my problem - how deal with status and message fields, returned from server and needed to display data in Fragment.

Answer 1

It depends a little bit, on what information you plan to display on the Fragment .

Will you show error messages to the user if there is a problem with the network? Or will you be happy just showing a "user not found" message.

Data that you plan to show the user should make its way into the ViewModel .

If you intend to show the error message from the Api directly, pass that to the ViewModel .

If you intend to show the user only, then pass that to the ViewModel . In this case, the error messages can only be generalized.

Answer 2

Here is how I do this:

Repository:

prival final MutableLiveData<User> userData = new MutableLiveData<>();

public void getUser(){
//post user to userData when you got response from the server
}
public LiveData<User> getUserData(){ return userData; }

ViewModel:

public LiveData<User> user = Repository.getInstance().getUserData();

In this case you viewModel won't create liveData each time, it will take liveData from Repository. Moreover, u will have loaded data inside your repo, so you will not have to trigger calls that often.

If you need to have knowledge of each call status, create something like DataSource holder object with your NetworkState enum inside liveData and response obj livedata

Here is my RemoteDataSource:

public class RemoteDataSource<T> {
    private final MutableLiveData<NetworkState> networkState = new MutableLiveData<>();
    private final MutableLiveData<T> data = new MutableLiveData<>();
    private final Action action;
    private String errorMessage;

    public RemoteDataSource(Action action) {
        networkState.postValue(NetworkState.Default);
        this.action = action;
    }

    public MutableLiveData<NetworkState> getNetworkState() {
        return networkState;
    }

    public void setIsLoading() {
        networkState.postValue(NetworkState.Loading);
    }

    public void setDefault() {
        networkState.postValue(NetworkState.Default);
    }

    public void setIsLoaded(T data) {
        networkState.postValue(NetworkState.Loaded);
        this.data.postValue(data);
    }

    public void setFailed(@NonNull String errorMessage) {
        this.errorMessage = errorMessage;
        networkState.postValue(NetworkState.Failed);
    }

    public String getErrorMessage() {
        return errorMessage;
    }

    public MutableLiveData<T> getData() {
        return data;
    }

    public void executeLoad() {
        if (action != null) {
            try {
                action.run();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Answer 3

I use repository pattern to just keep simple actions to retrieve the needed infos, nothing really complex:

https://github.com/ApploverSoftware/android-mvvm-architecture/blob/master/app/src/main/java/pl/applover/architecture/mvvm/data/example/repositories/ExampleCitiesRepository.kt

/**
 * Repository that exposes DataSources and Observables for loading data from local/network sources
 * Repository also exposes Subjects that inform about state of the calls
 */
class ExampleCitiesRepository @Inject constructor(private val apiCities: ExampleCitiesApiEndpointsInterface,
                                                  private val daoCities: ExampleCityDao) {

    fun citiesDataSourceFactory(compositeDisposable: CompositeDisposable) = CitiesDataSourceFactory(apiCities, compositeDisposable)

    fun citiesFromNetwork() =
            apiCities.getCitiesList().mapResponseList(mapper = { ExampleCityModel(it) })

    fun pagedCitiesFromDatabase() = daoCities.citiesPagedById().map { ExampleCityModel(it) }

    fun citiesFromDatabase() = daoCities.citiesById().map { it.map { ExampleCityModel(it) } }!!

    fun saveAllCitiesToDatabase(cities: Collection<ExampleCityModel>) = Single.fromCallable { daoCities.insertOrReplaceAll(cities.map { ExampleCityDbModel(it) }) }!!

    fun deleteAllCitiesFromDatabase() = Single.fromCallable { daoCities.deleteAll() }!!

}

Additionally I am mapping "Backend models" to app models (I don't like creating one model as backend can change their model and then it forces us to change our model too). That's all, I can get model that I want to work on, posibility to end the call using Rx's dispose or get error code or message using this.

ViewModels work nicely with this as we can get callback when viewModel is not needed anymore and then we can cancel network calls. We can continue making network calls if application isn't opened as live data secures to deliver the data from ViewModel to View in right time

Answer 4

Using Retrofit,
you can get response in Callback Class,
you must create a new class extends that,

class SampleCallback(private var mContext: Context) : Callback<SampleResponse> {
    override fun onResponse(call: Call<SampleResponse>, response: Response<SampleResponse>) {
        when (response.code()) {
            200-> //Update your View with mContext
        }
    }
}

don't forget to overwrite onFailure.