Was ist der Unterschied zwischen MediatorLiveData und MutableLiveData in MVVM?

Ich habe viel gesucht, aber keine kristallklare Antwort auf die Fragen gefunden:

1. Was ist der Unterschied zwischen MediatorLiveData und MutableLiveData?

2. Was sind die geeigneten Bedingungen, um eine von ihnen zu verwenden.

Zuerst müssen wir wissen, wie die Beziehung zwischen MutableLivedata und MediatorLivedata ist , um den Unterschied zwischen ihnen zu verstehen.

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

Jetzt ist klar, dass MediatorLiveData eine Unterklasse von MutableLiveData ist, daher kann MediatorLiveData auf jede Eigenschaft von MutableLiveData sowie auf LiveData zugreifen.

Frage Nr. 1 wird teilweise beantwortet und der Rest der Antwort wird am Ende von Frage Nr. Antwort von 2.

Nachdem ich einige Beispielprojekte sowie die offizielle Website des Android-Entwicklers recherchiert hatte, stellte ich fest, dass MutableLiveData nur zur Benachrichtigung Ihrer Benutzeroberfläche bei der Beobachtung von Daten verwendet werden sollte.

Sie möchten beispielsweise zwei SeekBars auf zwei verschiedenen Fragmenten (Fragment1 und Fragment2) anzeigen und sie möchten auch synchronisiert werden, wenn Sie von Fragment1 aus arbeiten.

Ein anderes Szenario ist, dass wir zwei Instanzen von LiveData haben, nennen wir sie liveData1 und liveData2, und wir möchten ihre Emissionen in einem Objekt zusammenführen: liveDataMerger (das ist ein MediatorLiveData-Objekt). Dann werden liveData1 und liveData2 zu Quellen für den liveDataMerger, und jedes Mal, wenn ein onChanged-Rückruf für einen von beiden aufgerufen wird, legen wir in liveDataMerger einen neuen Wert fest.

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

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

In diesem Fall können Sie MutableLiveData nicht verwenden. Wenn Sie jedoch Daten mit dem ersten Beispiel vergleichen möchten (in dem MutableLiveData verwendet wurde), können Sie dies nicht, da Sie die Eigenschaft addSource (gemäß Klassenhierarchie) nicht verwenden können.

MutableLiveData ist eine Unterklasse von LiveData, die die Methoden setValue und postValue verfügbar macht (die zweite ist threadsicher), sodass Sie einen Wert an alle aktiven Beobachter senden können.

MediatorLiveData kann andere LiveData-Objekte (Quellen) beobachten und auf deren onChange-Ereignisse reagieren. Auf diese Weise können Sie steuern, wann Sie das Ereignis weitergeben oder etwas Besonderes tun möchten.

Schauen Sie sich das folgende Google-Beispiel an:

Nehmen wir an, wir möchten nur 10 von liveData1 ausgegebene Werte im liveDataMerger zusammenführen. Nach 10 Werten können wir dann aufhören, liveData1 zu hören, und es als Quelle entfernen.

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)
        }
    }
})

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

Sie fügen mediatorLiveData 2 liveData hinzu, indem Sie die addSource () -Methode von mediatorLiveData verwenden. Die Definition der Methode addSource () lautet wie folgt:

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

onChanged Observer wird aufgerufen, wenn der Quellwert geändert wurde. In diesem Beobachter können Sie Werte in mediatorLiveData ausgeben (Sie können die Methoden setValue () und postValue () aufrufen). Auf diese Weise haben Sie 1 mediatorLiveData, die 2 liveData abhört. Wenn sich die Daten in liveData1 oder liveData2 ändern, wird der Beobachter von mediatorLiveData aufgerufen! Warum? Weil Sie im zweiten Argument der addSource () -Methode von MediatorLiveData Emissionen in mediatorLiveData vorgenommen haben.

MediatorLiveData ist eine Unterklasse von MutableLiveData , die andere LiveData-Objekte beobachten und auf OnChanged-Ereignisse reagieren kann.

Wenn Ihre Benutzeroberfläche beispielsweise ein LiveData-Objekt enthält, das aus einer lokalen Datenbank oder einem Netzwerk aktualisiert werden kann, können Sie dem MediatorLiveData-Objekt die folgenden Quellen hinzufügen: Ein LiveData-Objekt, das den in der Datenbank gespeicherten Daten zugeordnet ist. Ein LiveData-Objekt, das den Daten zugeordnet ist, auf die über das Netzwerk zugegriffen wird. Ihre Aktivität muss nur das MediatorLiveData-Objekt beobachten, um Aktualisierungen von beiden Quellen zu erhalten.

MediatorLiveData bietet Methoden zum Hinzufügen und Entfernen von Quellen -

• addSource (LiveData-Quelle, Observer onChanged)
• removeSource (LiveData toRemote)

Überprüfen Sie das offizielle Dokument hier zum Beispiel - https://developer.android.com/reference/android/arch/lifecycle/MediatorLiveData

Eine gute Lektüre zu LiveData finden Sie hier - https://medium.com/@elye.project/understanding-live-data-made-simple-a820fcd7b4d0

MediatorLiveDataHalten Sie ein applicationObjekt, um eine Bedingung zu behandeln. Beispiel: Möglicherweise müssen Sie einen Systemdienst wie LocationManager oder Resource verarbeiten. Und Sie können dataEventüber liefern MediatorLiveData. MutableLiveDatahat kein Mitglied wie MediatorLiveDataist.