LiveData-Übersicht Teil von Android Jetpack

LiveData ist ein beobachtbarer Wert Data Holder-Klasse. Anders als bei regulären beobachtbaren Daten berücksichtigt LiveData Das bedeutet, dass der Lebenszyklus anderer App-Komponenten wie Aktivitäten, Fragmente oder Dienste. Dadurch wird sichergestellt, dass LiveData die App nur aktualisiert. Komponentenbeobachter, die sich in einem aktiven Lebenszyklusstatus befinden.

LiveData betrachtet einen Beobachter, der durch die Observer-Kurs, für die Teilnahme an einem aktiv, wenn sich ihr Lebenszyklus in der STARTED oder RESUMED Bundesstaat. LiveData benachrichtigt nur aktive Beobachter über Aktualisierungen. Inaktiv Beobachtende, die sich LiveData-Objekte sind nicht werden über Änderungen benachrichtigt.

Sie können einen Beobachter in Verbindung mit einem Objekt registrieren, das die Funktion LifecycleOwner . Durch diese Beziehung kann der Beobachter entfernt werden, wenn der Zustand die entsprechende Objektänderungen für Lifecycle bis DESTROYED Dies ist besonders nützlich für Aktivitäten und Fragmente, da sie LiveData-Objekte beobachten und müssen sich keine Gedanken über Datenlecks machen, denn Aktivitäten und Fragmente werden sofort erkannt. werden abgemeldet, wenn ihre Lebenszyklen gelöscht werden.

Weitere Informationen zur Verwendung von LiveData finden Sie unter Mit LiveData arbeiten. Objekte.

Die Vorteile von LiveData

Die Verwendung von LiveData bietet folgende Vorteile:

Sorgt dafür, dass Ihre UI dem Datenstatus entspricht
LiveData folgen dem Beobachtermuster. LiveData benachrichtigt Observer-Objekte, wenn zugrunde liegende Datenänderungen. Sie können Ihren Code zur Aktualisierung der Benutzeroberfläche in diese Observer Objekte. So müssen Sie die Benutzeroberfläche nicht nach jeder wenn sich die App-Daten ändern, weil der Beobachter dies für Sie erledigt.
Keine Speicherlecks
Beobachtende sind an Lifecycle-Objekte und nach sich selbst bereinigen, wenn der zugehörige Lebenszyklus gelöscht wird.
Keine Abstürze aufgrund angehaltener Aktivitäten
Wenn der Lebenszyklus des Beobachters inaktiv ist, z. B. bei einer Aktivität in an den Back Stack gebunden ist, werden keine LiveData-Ereignisse empfangen.
Keine manuelle Lebenszyklusbehandlung mehr
UI-Komponenten beobachten nur relevante Daten und beenden oder fortsetzen die Beobachtung nicht. LiveData verwaltet all dies automatisch, da es die relevanten während der Beobachtung verändert wird.
Daten immer aktuell
Wenn ein Lebenszyklus inaktiv wird, erhält er die neuesten Daten, wieder aktiv sind. Beispielsweise erhält eine Aktivität, die im Hintergrund ausgeführt wurde, das Ereignis direkt nachdem sie wieder im Vordergrund angezeigt wird.
Korrekte Konfigurationsänderungen
Wenn eine Aktivität oder ein Fragment aufgrund einer Konfigurationsänderung neu erstellt wird, z. B. erhält er sofort die neuesten verfügbaren Daten.
Ressourcen freigeben
Sie können eine LiveData verlängern mithilfe des Singleton-Musters, um Systemdienste so zu umschließen, die in Ihrer App geteilt wurden. Das Objekt LiveData stellt eine Verbindung zum Systemdienst her. Dann kann jeder Beobachter, der die Ressource benötigt, die LiveData -Objekt enthält. Weitere Informationen findest du unter LiveData erweitern.

Mit LiveData-Objekten arbeiten

Befolgen Sie diese Schritte, um LiveData-Objekte:

  1. Erstellen Sie eine Instanz von LiveData, die einen bestimmten Datentyp enthalten soll. Dies ist normalerweise in Ihrem Klasse ViewModel.
  2. Observer erstellen , das die onChanged() -Methode, die steuert, was passiert, wenn die Hold-Daten des LiveData-Objekts Änderungen. Normalerweise erstellen Sie ein Observer-Objekt in einem UI-Controller wie Aktivität oder Fragment.

  3. Anhängen des Objekts Observer an das Objekt LiveData mithilfe der Methode observe()-Methode. Die Methode observe() nimmt eine LifecycleOwner -Objekt enthält. Dadurch wird das Observer-Objekt vom LiveData-Objekt abonniert, sodass dass es über Änderungen informiert wird. Normalerweise hängen Sie das Observer-Objekt in einem UI-Controller, wie z. B. eine Aktivität oder ein Fragment.

Wenn Sie den im LiveData-Objekt gespeicherten Wert aktualisieren, werden alle registrierte Beobachter, solange die angehängte LifecycleOwner im aktiven Bundesstaat.

Mit LiveData können UI-Controller-Beobachter Updates abonnieren. Wenn die Daten LiveData-Objekt geändert wird, wird die Benutzeroberfläche als Reaktion automatisch aktualisiert.

LiveData-Objekte erstellen

LiveData ist ein Wrapper, der mit allen Daten verwendet werden kann, einschließlich Objekten, die Implementieren Sie Collections, z. B. List. A LiveData-Objekt ist normalerweise gespeichert in einem ViewModel -Objekt und wird über eine Getter-Methode aufgerufen, wie im Folgenden gezeigt. Beispiel:

Kotlin

class NameViewModel : ViewModel() {

    // Create a LiveData with a String
    val currentName: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }

    // Rest of the ViewModel...
}

Java

public class NameViewModel extends ViewModel {

    // Create a LiveData with a String
    private MutableLiveData<String> currentName;

    public MutableLiveData<String> getCurrentName() {
        if (currentName == null) {
            currentName = new MutableLiveData<String>();
        }
        return currentName;
    }

    // Rest of the ViewModel...
}

Zu Beginn sind die Daten in einem LiveData-Objekt nicht festgelegt.

<ph type="x-smartling-placeholder">
</ph>

Weitere Informationen zu den Vorteilen und der Nutzung des ViewModel-Kurses findest du in der ViewModel-Anleitung

LiveData-Objekte beobachten

In den meisten Fällen ist die onCreate()-Methode einer App-Komponente der richtige Ort, um mit der Beobachtung eines Objekt LiveData für das folgenden Gründen:

  • Damit das System keine redundanten Anrufe aus einer Aktivität oder Methode onResume() des Fragments.
  • Um sicherzustellen, dass die Aktivität oder das Fragment Daten enthält, die so schnell angezeigt werden können sobald er aktiv wird. Sobald sich eine App-Komponente im STARTED erhält er den neuesten Wert von den LiveData-Objekten, die er zu beobachten. Dies tritt nur auf, wenn das zu beobachtende LiveData-Objekt festgelegt.

Im Allgemeinen stellt LiveData Aktualisierungen nur dann bereit, wenn sich Daten ändern, und nur an aktive Beobachtende. Eine Ausnahme von diesem Verhalten besteht darin, dass Beobachter werden aktualisiert, wenn ihr Status von „Inaktiv“ zu „Aktiv“ wechselt. Wenn das der Beobachter ein zweites Mal von inaktiv zu aktiv wechselt, erhält er nur eine aktualisiert, wenn sich der Wert seit seiner letzten Aktivierung geändert hat.

Der folgende Beispielcode zeigt, wie ein LiveData beobachtet wird -Objekt enthält:

Kotlin

class NameActivity : AppCompatActivity() {

    // Use the 'by viewModels()' Kotlin property delegate
    // from the activity-ktx artifact
    private val model: NameViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Other code to setup the activity...

        // Create the observer which updates the UI.
        val nameObserver = Observer<String> { newName ->
            // Update the UI, in this case, a TextView.
            nameTextView.text = newName
        }

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        model.currentName.observe(this, nameObserver)
    }
}

Java

public class NameActivity extends AppCompatActivity {

    private NameViewModel model;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Other code to setup the activity...

        // Get the ViewModel.
        model = new ViewModelProvider(this).get(NameViewModel.class);

        // Create the observer which updates the UI.
        final Observer<String> nameObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {
                // Update the UI, in this case, a TextView.
                nameTextView.setText(newName);
            }
        };

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        model.getCurrentName().observe(this, nameObserver);
    }
}

Nachher observe() wird aufgerufen und nameObserver übergeben als Parameter onChanged() wird sofort mit dem zuletzt in mCurrentName gespeicherten Wert aufgerufen. Wenn das LiveData-Objekt keinen Wert in mCurrentName festgelegt hat, ist onChanged() nicht aufgerufen.

LiveData-Objekte aktualisieren

LiveData hat keine öffentlich verfügbaren Methoden zum Aktualisieren der gespeicherten Daten. Die MutableLiveData gibt die Klasse setValue(T) und postValue(T) und Sie müssen diese verwenden, wenn Sie den Wert bearbeiten müssen, der in Ein LiveData-Objekt. Normalerweise MutableLiveData wird verwendet in: ViewModel und dann den ViewModel macht nur unveränderliche LiveData-Objekte für die Beobachter verfügbar.

Nachdem Sie die Beobachterbeziehung eingerichtet haben, können Sie den Wert aktualisieren des LiveData-Objekts, wie im folgenden Beispiel dargestellt. löst alle Beobachter aus, wenn Nutzende auf eine Schaltfläche tippen:

Kotlin

button.setOnClickListener {
    val anotherName = "John Doe"
    model.currentName.setValue(anotherName)
}

Java

button.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        String anotherName = "John Doe";
        model.getCurrentName().setValue(anotherName);
    }
});

Wenn in diesem Beispiel setValue(T) aufgerufen wird, rufen die Beobachter ihre onChanged() mit dem Wert John Doe. Das Beispiel zeigt das Drücken einer Taste, setValue() oder postValue() könnten aufgerufen werden, um mName für verschiedene z. B. aufgrund einer Netzwerkanfrage oder einer Datenbanklast Abschluss; In allen Fällen wird der Aufruf von setValue() oder postValue() ausgelöst. und aktualisiert die Benutzeroberfläche.

LiveData mit Raumdaten verwenden

Die Persistenzbibliothek Room unterstützt beobachtbare Abfragen erstellen, LiveData-Objekten Beobachtbare Abfragen werden als Teil eines Database Access Object (DAO) geschrieben.

Room generiert den gesamten erforderlichen Code zum Aktualisieren des LiveData-Objekts, wenn ein die Datenbank aktualisiert wird. Der generierte Code führt die Abfrage asynchron auf einem im Hintergrund. Dieses Muster ist nützlich, um die Daten die in einer Benutzeroberfläche synchron mit den in einer Datenbank gespeicherten Daten angezeigt werden. Weitere Informationen über „Room“ und DAOs in der „Persistent Room“-Bibliothek .

Koroutinen mit LiveData verwenden

LiveData unterstützt Kotlin-Koroutinen. Weitere Informationen finden Sie unter Kotlin-Koroutinen mit Android-Architekturkomponenten verwenden

LiveData in der Architektur einer App

LiveData berücksichtigt den Lebenszyklus von Entitäten wie Aktivitäten und Fragmente. LiveData verwenden, um zwischen diesen Lebenszyklusn zu kommunizieren Eigentümer und andere Objekte mit unterschiedlicher Lebensdauer, z. B. ViewModel-Objekte. Die Hauptaufgabe von ViewModel besteht darin, UI-bezogene Elemente zu laden und zu verwalten. -Daten. Daher eignet er sich hervorragend zum Speichern von LiveData-Objekten. Erstellen LiveData-Objekte in der ViewModel und verwenden sie, um den Status in der UI verfügbar zu machen Ebene.

Aktivitäten und Fragmente sollten keine LiveData Instanzen enthalten, da ihre Rolle Daten anzuzeigen und nicht den Hold-Status. Außerdem werden Aktivitäten und Fragmente für das Speichern von Daten erleichtert das Schreiben von Einheitentests.

Es mag verlockend sein, LiveData-Objekte in Ihrer Datenschichtklasse zu arbeiten, aber LiveData ist nicht für die Verarbeitung asynchroner Datenströme vorgesehen. Obwohl können Sie LiveData-Transformationen und MediatorLiveData Um dies zu erreichen, hat dieser Ansatz Nachteile: Die Möglichkeit, Streams der Daten ist sehr begrenzt und alle LiveData-Objekte (einschließlich der erstellten durch Transformationen) im Hauptthread beobachtet werden. Der folgende Code ist ein Beispiel dafür, wie ein LiveData im Repository dazu führen kann, dass der Haupt- Thread:

Kotlin

class UserRepository {

    // DON'T DO THIS! LiveData objects should not live in the repository.
    fun getUsers(): LiveData<List<User>> {
        ...
    }

    fun getNewPremiumUsers(): LiveData<List<User>> {
        return getUsers().map { users ->
            // This is an expensive call being made on the main thread and may
            // cause noticeable jank in the UI!
            users
                .filter { user ->
                  user.isPremium
                }
          .filter { user ->
              val lastSyncedTime = dao.getLastSyncedTime()
              user.timeCreated > lastSyncedTime
                }
    }
}

Java

class UserRepository {

    // DON'T DO THIS! LiveData objects should not live in the repository.
    LiveData<List<User>> getUsers() {
        ...
    }

    LiveData<List<User>> getNewPremiumUsers() {
    return Transformations.map(getUsers(),
        // This is an expensive call being made on the main thread and may cause
        // noticeable jank in the UI!
        users -> users.stream()
            .filter(User::isPremium)
            .filter(user ->
                user.getTimeCreated() > dao.getLastSyncedTime())
            .collect(Collectors.toList()));
    }
}

Wenn Sie Datenstreams in anderen Ebenen Ihrer App verwenden müssen, mithilfe von Kotlin-Abläufen und Konvertieren in LiveData in der ViewModel mit asLiveData(). Weitere Informationen zur Verwendung von Flow mit Kotlin mit LiveData finden Sie in diesem Codelab. Für Codebasen, die mit Java erstellt wurden, sollten Sie Executors verwenden. in Verbindung mit Callbacks oder RxJava verwendet werden.

LiveData erweitern

LiveData betrachtet einen Beobachter als aktiv, wenn befindet sich entweder im STARTED oder RESUMED Bundesländer. Der folgende Beispielcode zeigt, wie die Klasse LiveData:

Kotlin

class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
    private val stockManager = StockManager(symbol)

    private val listener = { price: BigDecimal ->
        value = price
    }

    override fun onActive() {
        stockManager.requestPriceUpdates(listener)
    }

    override fun onInactive() {
        stockManager.removeUpdates(listener)
    }
}

Java

public class StockLiveData extends LiveData<BigDecimal> {
    private StockManager stockManager;

    private SimplePriceListener listener = new SimplePriceListener() {
        @Override
        public void onPriceChanged(BigDecimal price) {
            setValue(price);
        }
    };

    public StockLiveData(String symbol) {
        stockManager = new StockManager(symbol);
    }

    @Override
    protected void onActive() {
        stockManager.requestPriceUpdates(listener);
    }

    @Override
    protected void onInactive() {
        stockManager.removeUpdates(listener);
    }
}

Die Implementierung des Preis-Listeners in diesem Beispiel umfasst Folgendes: wichtige Methoden:

  • Die onActive() -Methode wird aufgerufen, wenn das LiveData-Objekt einen aktiven Beobachter hat. Das bedeutet, müssen Sie die Aktualisierungen der Aktienkurse mit dieser Methode beobachten.
  • Die onInactive() wird aufgerufen, wenn das LiveData-Objekt keine aktiven Beobachter hat. Da keine Beobachter zuhören, gibt es keinen Grund, sich mit den Inhalten StockManager-Dienst.
  • Die setValue(T) aktualisiert den Wert der LiveData-Instanz und benachrichtigt alle aktiven Beobachtende über die Veränderung.

Sie können die Klasse StockLiveData so verwenden:

Kotlin

public class MyFragment : Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val myPriceListener: LiveData<BigDecimal> = ...
        myPriceListener.observe(viewLifecycleOwner, Observer<BigDecimal> { price: BigDecimal? ->
            // Update the UI.
        })
    }
}

Java

public class MyFragment extends Fragment {
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        LiveData<BigDecimal> myPriceListener = ...;
        myPriceListener.observe(getViewLifecycleOwner(), price -> {
            // Update the UI.
        });
    }
}

Die observe() übergibt die LifecycleOwner mit der Ansicht des Fragments als erstes Argument verknüpft ist. Dies bedeutet, dass Dieser Beobachter ist an das Lifecycle-Objekt gebunden mit dem Inhaber verknüpft ist, d. h.:

  • Wenn das Lifecycle-Objekt nicht aktiv ist, ist der Beobachter nicht auch wenn sich der Wert ändert.
  • Nach dem Löschen des Lifecycle-Objekts wird der Beobachter automatisch entfernt.

Da LiveData-Objekte den Lebenszyklus berücksichtigen, können Sie zwischen mehreren Aktivitäten, Fragmenten und Diensten. Um das Beispiel können Sie die Klasse LiveData wie folgt als Singleton implementieren:

Kotlin

class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
    private val stockManager: StockManager = StockManager(symbol)

    private val listener = { price: BigDecimal ->
        value = price
    }

    override fun onActive() {
        stockManager.requestPriceUpdates(listener)
    }

    override fun onInactive() {
        stockManager.removeUpdates(listener)
    }

    companion object {
        private lateinit var sInstance: StockLiveData

        @MainThread
        fun get(symbol: String): StockLiveData {
            sInstance = if (::sInstance.isInitialized) sInstance else StockLiveData(symbol)
            return sInstance
        }
    }
}

Java

public class StockLiveData extends LiveData<BigDecimal> {
    private static StockLiveData sInstance;
    private StockManager stockManager;

    private SimplePriceListener listener = new SimplePriceListener() {
        @Override
        public void onPriceChanged(BigDecimal price) {
            setValue(price);
        }
    };

    @MainThread
    public static StockLiveData get(String symbol) {
        if (sInstance == null) {
            sInstance = new StockLiveData(symbol);
        }
        return sInstance;
    }

    private StockLiveData(String symbol) {
        stockManager = new StockManager(symbol);
    }

    @Override
    protected void onActive() {
        stockManager.requestPriceUpdates(listener);
    }

    @Override
    protected void onInactive() {
        stockManager.removeUpdates(listener);
    }
}

Und Sie können es wie folgt im Fragment verwenden:

Kotlin

class MyFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        StockLiveData.get(symbol).observe(viewLifecycleOwner, Observer<BigDecimal> { price: BigDecimal? ->
            // Update the UI.
        })

    }

Java

public class MyFragment extends Fragment {
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        StockLiveData.get(symbol).observe(getViewLifecycleOwner(), price -> {
            // Update the UI.
        });
    }
}

Mehrere Fragmente und Aktivitäten können die Instanz MyPriceListener beobachten. LiveData stellt nur dann eine Verbindung zum Systemdienst her, wenn mindestens einer von ihnen sichtbar ist und aktiv sind.

LiveData transformieren

Vielleicht möchten Sie Änderungen an dem Wert vornehmen, der in einem LiveData-Objekt vor an die Beobachter weiterleiten. Eventuell müssen Sie auch LiveData-Instanz auf Basis des Werts einer anderen Instanz. Die Lifecycle-Paket stellt die Transformations Klasse, die Hilfsmethoden enthält, die diese Szenarien unterstützen.

Transformations.map()
Wendet eine Funktion auf den im LiveData-Objekt gespeicherten Wert an und wird das Ergebnis nachgelagert.

Kotlin

val userLiveData: LiveData<User> = UserLiveData()
val userName: LiveData<String> = userLiveData.map {
    user -> "${user.name} ${user.lastName}"
}

Java

LiveData<User> userLiveData = ...;
LiveData<String> userName = Transformations.map(userLiveData, user -> {
    user.name + " " + user.lastName
});
Transformations.switchMap()
Wurde ähnlich wie map() eine Funktion auf den Wert angewendet, der in LiveData gespeichert ist -Objekt und entpackt und sendet das Ergebnis nachgelagert. Die übergebene Funktion an switchMap() muss ein LiveData-Objekt zurückgeben, wie im folgendes Beispiel:

Kotlin

private fun getUser(id: String): LiveData<User> {
  ...
}
val userId: LiveData<String> = ...
val user = userId.switchMap { id -> getUser(id) }

Java

private LiveData<User> getUser(String id) {
  ...;
}

LiveData<String> userId = ...;
LiveData<User> user = Transformations.switchMap(userId, id -> getUser(id) );

Sie können Transformationsmethoden verwenden, um Informationen über die Lebenszyklus. Die Transformationen werden nur berechnet, wenn ein Beobachter beobachtet Das zurückgegebene LiveData-Objekt. Da die Transformationen berechnet werden, Lebenszyklus-bezogenes Verhalten implizit weitergegeben wird, ohne dass expliziten Aufrufen oder Abhängigkeiten hinzugefügt werden.

Wenn Sie glauben, dass Sie ein Lifecycle-Objekt in einem Objekt ViewModel, ein ist wahrscheinlich die bessere Lösung. Angenommen, Sie haben eine UI-Komponente, die eine Adresse annimmt und die Postleitzahl dafür zurückgibt Adresse. Sie können das naive ViewModel für diese Komponente als Dies wird durch folgenden Beispielcode veranschaulicht:

Kotlin

class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {

    private fun getPostalCode(address: String): LiveData<String> {
        // DON'T DO THIS
        return repository.getPostCode(address)
    }
}

Java

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;
    public MyViewModel(PostalCodeRepository repository) {
       this.repository = repository;
    }

    private LiveData<String> getPostalCode(String address) {
       // DON'T DO THIS
       return repository.getPostCode(address);
    }
}

Die UI-Komponente muss dann die Registrierung beim vorherigen LiveData-Objekt aufheben. und sich bei der neuen Instanz registrieren, wenn sie getPostalCode() aufruft. In Wird die UI-Komponente neu erstellt, löst sie einen weiteren Aufruf an die repository.getPostCode()-Methode, anstatt das Ergebnis des vorherigen Aufrufs zu verwenden.

Stattdessen können Sie die Postleitzahlsuche als Transformation des wie im folgenden Beispiel gezeigt:

Kotlin

class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {
    private val addressInput = MutableLiveData<String>()
    val postalCode: LiveData<String> = addressInput.switchMap {
            address -> repository.getPostCode(address) }


    private fun setInput(address: String) {
        addressInput.value = address
    }
}

Java

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;
    private final MutableLiveData<String> addressInput = new MutableLiveData();
    public final LiveData<String> postalCode =
            Transformations.switchMap(addressInput, (address) -> {
                return repository.getPostCode(address);
             });

  public MyViewModel(PostalCodeRepository repository) {
      this.repository = repository
  }

  private void setInput(String address) {
      addressInput.setValue(address);
  }
}

In diesem Fall ist das Feld postalCode als Transformation des addressInput. Solange Ihre App einen aktiven Beobachter hat, der mit dem postalCode, wird der Wert des Felds neu berechnet und abgerufen, wenn addressInput Änderungen.

Durch diesen Mechanismus können niedrigere App-Ebenen LiveData-Objekte erstellen, die werden verzögert bei Bedarf berechnet. Ein ViewModel-Objekt kann problemlos auf LiveData-Objekte verweisen und dann Transformationsregeln .

Neue Transformationen erstellen

Es gibt ein Dutzend verschiedener Transformationen, die in Ihrem Sie werden aber nicht standardmäßig bereitgestellt. Eigene Transformation implementieren können Sie den MediatorLiveData und hört andere LiveData-Objekte und die von ihnen ausgegeben werden. MediatorLiveData gibt seine zum LiveData-Quellobjekt hinzu. Weitere Informationen zu diesem Muster finden Sie in der die Referenzdokumentation der Transformations .

Mehrere LiveData-Quellen zusammenführen

MediatorLiveData ist eine abgeleitete Klasse von LiveData, ermöglicht das Zusammenführen mehrerer LiveData-Quellen. Beobachter von MediatorLiveData -Objekte werden immer dann ausgelöst, wenn eines der ursprünglichen LiveData-Quellobjekte ändern können.

Wenn Sie z. B. ein LiveData-Objekt in Ihrer Benutzeroberfläche haben, das über eine lokale Datenbank oder ein Netzwerk haben, können Sie folgende Quellen zum MediatorLiveData-Objekt:

  • Ein LiveData-Objekt, das den in der Datenbank gespeicherten Daten zugeordnet ist.
  • Ein LiveData-Objekt, das mit den Daten verknüpft ist, auf die aus dem Netzwerk zugegriffen wird.

Deine Aktivität muss nur das MediatorLiveData-Objekt beobachten, um Aktualisierungen aus beiden Quellen. Ein detailliertes Beispiel finden Sie im Zusatz: Offenlegen Netzwerkstatus im App-Leitfaden Architektur.

Weitere Informationen

Weitere Informationen zur Klasse LiveData, Beratung in den folgenden Ressourcen.

Produktproben

Codelabs

Blogs

Videos