Comment mettre à jour LiveData d'un ViewModel à partir du service d'arrière-plan et de l'interface utilisateur de mise à jour

Récemment, j'explore l'architecture Android, qui a été récemment introduite par Google. D'après la documentation, j'ai trouvé ceci:

public class MyViewModel extends ViewModel {
    private MutableLiveData<List<User>> users;
    public LiveData<List<User>> getUsers() {
        if (users == null) {
            users = new MutableLiveData<List<Users>>();
            loadUsers();
        }
        return users;
    }

    private void loadUsers() {
        // do async operation to fetch users
    }
}

l'activité peut accéder à cette liste comme suit:

public class MyActivity extends AppCompatActivity {
    public void onCreate(Bundle savedInstanceState) {
        MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
        model.getUsers().observe(this, users -> {
            // update UI
        });
    }
}

Ma question est, je vais faire ceci:

1. dans la loadUsers()fonction je récupère les données de manière asynchrone où je vais d'abord vérifier la base de données (Room) pour ces données

2. Si je n'obtiens pas les données là-bas, je passerai un appel API pour récupérer les données du serveur Web.

3. Je vais insérer les données récupérées dans la base de données (Room) et mettre à jour l'interface utilisateur en fonction des données.

Quelle est l'approche recommandée pour ce faire?

Si je lance un Serviceappel à l'API à partir de la loadUsers()méthode, comment puis-je mettre à jour la MutableLiveData<List<User>> usersvariable à partir de cela Service?

Je suppose que vous utilisez des composants d'architecture Android . En fait, peu importe où vous appelez service, asynctask or handlerpour mettre à jour les données. Vous pouvez insérer les données du service ou de l'asynctask à l'aide de la postValue(..)méthode. Votre classe ressemblerait à ceci:

private void loadUsers() {
    // do async operation to fetch users and use postValue() method
    users.postValue(listOfData)
}

Comme l' usersest LiveData, la Roombase de données est responsable de fournir des données des utilisateurs partout où il est inséré.

Note: Dans l'architecture de type MVVM, le référentiel est principalement responsable de la vérification et de l'extraction des données locales et des données distantes.

Vous pouvez utiliser la MutableLiveData<T>.postValue(T value)méthode du thread d'arrière-plan.

private void loadUsers() {
    // do async operation to fetch users and use postValue() method
   users.postValue(listOfData)
}

... dans la fonction loadUsers () Je récupère les données de manière asynchrone ... Si je démarre un service pour appeler l'API à partir de la méthode loadUsers (), comment puis-je mettre à jour la variable MutableLiveData> users à partir de ce service?

Si l'application récupère les données utilisateur sur un thread d'arrière-plan, postValue (plutôt que setValue ) sera utile.

Dans la méthode loadData, il y a une référence à l'objet "users" MutableLiveData. La méthode loadData récupère également des données utilisateur fraîches quelque part (par exemple, un référentiel).

Maintenant, si l'exécution se fait sur un thread d'arrière-plan, MutableLiveData.postValue () met à jour les observateurs extérieurs de l'objet MutableLiveData.

Peut-être quelque chose comme ça:

private MutableLiveData<List<User>> users;

.
.
.

private void loadUsers() {
    // do async operation to fetch users
    ExecutorService service =  Executors.newSingleThreadExecutor();
    service.submit(new Runnable() {
        @Override
        public void run() {
            // on background thread, obtain a fresh list of users
            List<String> freshUserList = aRepositorySomewhere.getUsers();

            // now that you have the fresh user data in freshUserList, 
            // make it available to outside observers of the "users" 
            // MutableLiveData object
            users.postValue(freshUserList);        
        }
    });

}

Jetez un œil au guide d'architecture Android qui accompagne les nouveaux modules d'architecture comme LiveDataet ViewModel. Ils discutent de cette question exacte en profondeur.

Dans leurs exemples, ils ne le mettent pas dans un service. Regardez comment ils le résolvent en utilisant un module «référentiel» et Retrofit. Les addenda en bas comprennent des exemples plus complets, notamment la communication de l'état du réseau, le signalement des erreurs, etc.

Si vous appelez votre API dans Repository,

Dans le référentiel :

public MutableLiveData<LoginResponseModel> checkLogin(LoginRequestModel loginRequestModel) {
    final MutableLiveData<LoginResponseModel> data = new MutableLiveData<>();
    apiService.checkLogin(loginRequestModel)
            .enqueue(new Callback<LoginResponseModel>() {
                @Override
                public void onResponse(@NonNull Call<LoginResponseModel> call, @Nullable Response<LoginResponseModel> response) {
                    if (response != null && response.isSuccessful()) {
                        data.postValue(response.body());
                        Log.i("Response ", response.body().getMessage());
                    }
                }

                @Override
                public void onFailure(@NonNull Call<LoginResponseModel> call, Throwable t) {
                    data.postValue(null);
                }
            });
    return data;
}

Dans ViewModel

public LiveData<LoginResponseModel> getUser() {
    loginResponseModelMutableLiveData = repository.checkLogin(loginRequestModel);
    return loginResponseModelMutableLiveData;
}

En activité / fragment

loginViewModel.getUser().observe(LoginActivity.this, loginResponseModel -> {
        if (loginResponseModel != null) {
            Toast.makeText(LoginActivity.this, loginResponseModel.getUser().getType(), Toast.LENGTH_SHORT).show();
        }
    });

Remarque: en utilisant JAVA_1.8 lambda ici, vous pouvez l'utiliser sans