Quelle est la différence entre MediatorLiveData et MutableLiveData dans MVVM ?

Question

J'ai beaucoup cherché mais je n'ai pas trouvé de réponse claire à mes questions :

1. Quelle est la différence entre MediatorLiveData et MutableLiveData ?

2. Quelles sont les conditions appropriées pour utiliser l'un ou l'autre ?

Answer 1

Tout d'abord, nous devons savoir quelle est la relation entre MutableLivedata y MediatorLivedata pour comprendre la différence entre eux.

java.lang.Object
   android.arch.lifecycle.LiveData<T>
       android.arch.lifecycle.MutableLiveData<T>
           android.arch.lifecycle.MediatorLiveData<T>

Il est maintenant clair que MediatorLiveData est une sous-classe de MutableLiveData ; MediatorLiveData peut donc accéder à toutes les propriétés de MutableLiveData et de LiveData.

La réponse à la question n° 1 est partielle et le reste de la réponse sera discuté à la fin de la réponse à la question n° 2.

Après avoir fait des recherches sur quelques exemples de projets ainsi que sur le site officiel des développeurs Android, j'ai découvert que MutableLiveData ne doit être utilisé que pour notifier votre interface utilisateur lorsqu'une donnée est observée.

Par exemple, vous voulez afficher deux barres de recherche sur deux fragments différents (Fragment1 et Fragment2) et vous voulez également qu'elles soient synchronisées lors de l'utilisation du Fragment1.

Un autre scénario est que nous avons 2 instances de LiveData, nommons-les liveData1 et liveData2, et nous voulons fusionner leurs émissions dans un seul objet : liveDataMerger (qui est un objet MediatorLiveData). Ensuite, liveData1 et liveData2 deviendront des sources pour le liveDataMerger et chaque fois que le callback onChanged est appelé pour l'une d'entre elles, nous définissons une nouvelle valeur dans le liveDataMerger.

LiveData liveData1 = ...;
LiveData liveData2 = ...;

MediatorLiveData liveDataMerger = new MediatorLiveData<>();
liveDataMerger.addSource(liveData1, value ->liveDataMerger.setValue(value));
liveDataMerger.addSource(liveData2, value -> liveDataMerger.setValue(value));

Dans ce cas, vous ne pouvez pas utiliser MutableLiveData mais d'un autre côté, si vous voulez comparer des données dans le premier exemple (où MutableLiveData a été utilisé), vous ne pouvez pas le faire car vous ne pourrez pas utiliser la propriété addSource (selon la hiérarchie des classes).

Answer 2

MutableLiveData est une sous-classe de LiveData qui expose les méthodes setValue et postValue (la seconde est thread safe), de sorte que vous pouvez envoyer une valeur à tous les observateurs actifs.

MediatorLiveData peut observer d'autres objets LiveData (sources) et réagir à leurs événements onChange, ce qui vous donnera le contrôle sur le moment où vous souhaitez propager l'événement, ou faire quelque chose en particulier.

Jetez un coup d'œil à l'exemple suivant de Google :

Considérons que nous voulons seulement 10 valeurs émises par liveData1, pour être fusionnées dans le liveDataMerger. Alors, après 10 valeurs, nous pouvons arrêter l'écoute de liveData1 et la supprimer en tant que source.

Java

liveDataMerger.addSource(liveData1, new Observer() {
      private int count = 1;

      @Override public void onChanged(@Nullable Integer s) {
          count++;
          liveDataMerger.setValue(s);
          if (count > 10) {
              liveDataMerger.removeSource(liveData1);
          }
      }
 });

Kotlin

liveDataMerger.addSource(liveData1, object : Observer<Int> {
    private var count = 1

    override fun onChanged(s: Int?) {
        count++
        liveDataMerger.value = s
        if (count > 10) {
            liveDataMerger.removeSource(liveData1)
        }
    }
})

Answer 3

MediatorLiveData<String> mediatorLiveData = new MediatorLiveData<String>();

public MutableLiveData<String> liveData1 = new  MutableLiveData<String>();
public MutableLiveData<String> liveData2 = new  MutableLiveData<String>();

mediatorLiveData.addSource(liveData1,
    new Observer<String>() {
        @Override
        public void onChanged(String s) {
            mediatorLiveData.setValue(s + " - emission from observer of liveData1");
        }
    }
);
mediatorLiveData.addSource(liveData2,
    new Observer<String>() {
        @Override
        public void onChanged(String s) {
            mediatorLiveData.setValue(s + " - emission from observer of liveData2");
        }
    }
)

mediatorLiveData.observe(this, new Observer<String>() {
    @Override
    public void onChanged(String s) {
        Toast.makeText(context, s , Toast.LENGTH_SHORT).show();
    }
});

liveData1.postValue("hello")    // output : hello - emission from observer of liveData1
liveData2.postValue("world")    // output : world - emission from observer of liveData2

Vous ajoutez 2 liveData à mediatorLiveData en utilisant la méthode addSource() de mediatorLiveData. La définition de la méthode addSource() est la suivante :

addSource(LiveData<S> source, Observer<S> onChanged)

L'observateur onChanged sera appelé lorsque la valeur de la source a été modifiée. Dans cet observateur, vous pouvez émettre des valeurs dans mediatorLiveData (vous pouvez invoquer les méthodes setValue(), postValue()). De cette façon, vous avez 1 mediatorLiveData qui écoute 2 liveData. Lorsque les données contenues dans liveData1 ou liveData2 changent, l'observateur de mediatorLiveData est invoqué ! Pourquoi ? Parce que vous avez fait des émissions dans mediatorLiveData dans le second argument de la méthode addSource() de MediatorLiveData.

Answer 4

MediatorLiveData est une sous-classe de MutableLiveData qui peut observer d'autres objets LiveData et réagir aux événements OnChanged de ces derniers.

Par exemple, si vous avez un objet LiveData dans votre interface utilisateur qui peut être mis à jour à partir d'une base de données locale ou d'un réseau, vous pouvez ajouter les sources suivantes à l'objet MediatorLiveData : Un objet LiveData associé aux données stockées dans la base de données. Un objet LiveData associé aux données accessibles depuis le réseau. Il suffit à votre activité d'observer l'objet MediatorLiveData pour recevoir les mises à jour des deux sources.

MediatorLiveData fournit des méthodes pour ajouter et supprimer la source -

• addSource(LiveData source, Observer onChanged)
• removeSource(LiveData toRemote)

Consultez le document officiel ici par exemple - https://developer.Android.com/reference/Android/arch/lifecycle/MediatorLiveData

Une bonne lecture sur LiveData, consultez ici - https://medium.com/@elye.project/understanding-live-data-made-simple-a820fcd7b4d0

Answer 5

MediatorLiveData tenir un application pour gérer certaines conditions. Par exemple, vous pouvez avoir besoin de traiter un service système tel que LocationManager ou Resource. Et vous pouvez fournir dataEvent via MediatorLiveData . MutableLiveData n'a pas de membre comme MediatorLiveData est.