Omówienie LiveData Zawiera Android Jetpack.

LiveData jest obiektem dostrzegalnym klasy właściciela danych. W przeciwieństwie do zwykłych obserwowalnych danych LiveData uwzględnia cykl życia, co oznacza, że uwzględnia cykl życia innych komponentów aplikacji, takich jak działania, fragmenty witryny lub usługi. Dzięki tej świadomości LiveData tylko aktualizuje aplikację obserwatorów komponentów w aktywnym stanie cyklu życia.

W przypadku LiveData obserwator jest reprezentowany przez Observer, aby być w stanu aktywności, jeśli jej cykl życia STARTED lub RESUMED stanu. LiveData powiadamia o aktualizacjach tylko aktywnych obserwatorów. Nieaktywny obserwatorzy zarejestrowani do oglądania LiveData obiektów nie jest powiadomienia o zmianach.

Możesz zarejestrować obserwatora sparowanego z obiektem, który implementuje metodę LifecycleOwner za pomocą prostego interfejsu online. Ta relacja umożliwia usunięcie obserwatora, gdy stan odpowiadający mu Liczba zmian obiektów: Lifecycle do DESTROYED Jest to szczególnie przydatne w przypadku działań i fragmentów, ponieważ mogą one bezpiecznie obserwuj obiekty LiveData i bez obaw o wyciek danych – aktywność i fragmenty są natychmiast dostępne anulowania subskrypcji po zniszczeniu ich cykli życia.

Więcej informacji o korzystaniu z LiveData znajdziesz w artykule Praca z LiveData .

Zalety używania LiveData

Używanie LiveData zapewnia te korzyści:

Prawidłowość, że interfejs użytkownika jest zgodny ze stanem danych
LiveData odbywa się na podstawie wzorca obserwatora. LiveData powiadamia Observer obiektów, gdy i podstawowych zmian danych. Możesz skonsolidować kod, aby zaktualizować interfejs w tych Observer obiektów. Dzięki temu nie będzie trzeba aktualizować interfejsu gdy obserwator robi to za Ciebie.
Brak wycieków pamięci
Obserwatorzy są powiązani z Lifecycle obiektów czyścić się po sobie, gdy powiązany z nimi cykl życia zostanie zniszczony.
Brak awarii z powodu zatrzymania działań
Jeśli cykl życia obserwatora jest nieaktywny – na przykład w przypadku aktywności zamiast stosu wstecznego nie otrzyma żadnych zdarzeń LiveData.
Koniec z ręczną obsługą cyklu życia produktu
Komponenty interfejsu obserwują tylko istotne dane i nie zatrzymują ani nie wznawiają obserwacji. LiveData zarządza tymi kwestiami automatycznie, ponieważ wie o istniejących stan cyklu życia zmienia się w trakcie obserwacji.
Zawsze aktualne dane
Jeśli cykl życia stanie się nieaktywny, po chwili uzyska najnowsze dane są ponownie aktywne. Na przykład działanie wykonywane w tle otrzymuje najnowsze dane zaraz po powrocie na pierwszy plan.
Prawidłowe zmiany konfiguracji
Jeśli działanie lub fragment zostały odtworzone z powodu zmiany konfiguracji, np. i natychmiast otrzymuje najnowsze dostępne dane.
Udostępnianie zasobów
Możesz przedłużyć LiveData za pomocą wzorca singletonu do opakowywania usług systemowych w taki sposób, aby mogły być udostępnione w aplikacji. Obiekt LiveData łączy się z usługą systemową raz, a każdy obserwator, który go potrzebuje, może obejrzeć LiveData obiektu. Więcej informacji znajdziesz w artykule o rozszerzeniu LiveData.

Praca z obiektami LiveData

Wykonaj te czynności, aby pracować z LiveData obiekty:

  1. Tworzenie instancji LiveData do przechowywania danych określonego typu. To jest zwykle odbywa się w ciągu ViewModel.
  2. Tworzenie Observer który określa onChanged() , która określa, co się dzieje, gdy zablokowane dane obiektu LiveData zmian. Obiekt Observer tworzysz zwykle w kontrolerze interfejsu użytkownika, taki jak aktywność lub fragment.

  3. Dołącz obiekt Observer do obiektu LiveData za pomocą observe(). Metoda observe() pobiera LifecycleOwner. obiektu. Powoduje to zasubskrybowanie obiektu Observer obiektu LiveData, że jest on powiadamiany o zmianach. Obiekt Observer zwykle załącza się w pliku kontroler UI, np. aktywność lub fragment.

Gdy zaktualizujesz wartość zapisaną w obiekcie LiveData, wywołasz wszystkie zarejestrowanych obserwatorów, gdy tylko podłączony LifecycleOwner jest aktywny stanu.

LiveData umożliwia obserwatorom kontrolera UI subskrybowanie aktualizacji. Kiedy dane przechowywanych przez zmiany obiektu LiveData, interfejs automatycznie aktualizuje się w odpowiedzi.

Tworzenie obiektów LiveData

LiveData to kod, którego można używać z dowolnymi danymi, w tym z obiektami, zaimplementuj funkcję Collections, np. List. O Obiekt LiveData jest zwykle przechowywane w ViewModel obiektu i jest uzyskiwany dostęp za pomocą metody getter, co pokazano w poniższym przykład:

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

Początkowo dane w obiekcie LiveData nie są ustawione.

Więcej informacji o zaletach i wykorzystaniu zajęć ViewModel znajdziesz w Przewodnik po ViewModel.

Obserwuj obiekty LiveData

W większości przypadków należy zacząć od metody onCreate() komponentu aplikacji. LiveData dla następujące przyczyny:

  • Aby system nie wykonywał dodatkowych połączeń w przypadku danej aktywności lub metody onResume() fragmentu.
  • Aby zapewnić, że aktywność lub fragment zawierają dane, które mogą zostać wyświetlone od razu gdy staje się ona aktywna. Gdy tylko komponent aplikacji znajdzie się w STARTED otrzymuje najnowszą wartość z obiektów LiveData, do obserwacji. Dzieje się tak tylko wtedy, gdy obiekt LiveData do zaobserwowania został ustawiony.

Ogólnie rzecz biorąc, LiveData aktualizuje się tylko wtedy, gdy dane ulegną zmianie, i tylko wtedy, gdy dane są aktywne obserwatorzy. Wyjątkiem od tego zachowania jest to, że obserwatorzy otrzymują też są aktualizowane, gdy zmieniają stan z nieaktywnego na aktywny. Ponadto, jeśli obserwatora po raz drugi zmienia się z nieaktywnego na aktywny, otrzymuje tylko aktualizować, jeśli wartość uległa zmianie od czasu jej ostatniej aktywności.

Ten przykładowy kod pokazuje, jak zacząć obserwować LiveData obiekt:

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

Po Funkcja observe() jest wywoływana z wartością nameObserver przekazywaną jako parametru onChanged() jest natychmiast wywoływana z podaniem najnowszej wartości zapisanej w mCurrentName. Jeśli obiekt LiveData nie ma ustawionej wartości w mCurrentName, onChanged() to nie wywołano.

Aktualizowanie obiektów LiveData

LiveData nie ma publicznie dostępnych metod aktualizowania przechowywanych danych. MutableLiveData klasa ujawnia setValue(T) oraz postValue(T) publicznie. Musisz ich używać, jeśli chcesz edytować wartości przechowywane w obiektem LiveData. Zwykle MutableLiveData jest używany w ViewModel, a potem Funkcja ViewModel ujawnia tylko obserwatorom tylko stałe obiekty LiveData.

Po skonfigurowaniu relacji z obserwatorem możesz zaktualizować wartość obiektu LiveData, jak pokazano w przykładzie poniżej, Powoduje uruchomienie wszystkich obserwatorów po kliknięciu przycisku przez użytkownika:

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

Wywołanie setValue(T) w przykładzie powoduje, że obserwatorzy nazywają swoje onChanged(). o wartości John Doe. Przykład pokazuje naciśnięcie przycisku, Można wywołać funkcję setValue() lub postValue() w celu aktualizacji mName dla różnych z różnych powodów, w tym w odpowiedzi na żądanie sieciowe lub obciążenie bazy danych ukończenie; we wszystkich przypadkach wywołanie setValue() lub postValue() aktywuje i aktualizuje interfejs użytkownika.

Używaj danych LiveData w pokojach

Biblioteka trwałości pokoi obsługuje obserwowalne zapytania, które zwracają LiveData obiektów. Obserwowalne zapytania są zapisywane jako część obiektu dostępu do bazy danych (DAO).

Sala generuje cały kod niezbędny do aktualizacji obiektu LiveData, gdy . Wygenerowany kod uruchamia zapytanie asynchronicznie na rozmowy w tle. Ten wzorzec jest przydatny do przechowywania danych wyświetlane w interfejsie zsynchronizowane z danymi przechowywanymi w bazie danych. Możesz dowiedzieć się więcej o salach i bibliotekach DAO w bibliotece trwałej .

Używanie współrzędnych z LiveData

LiveData zapewnia obsługę współprogramów Kotlin. Więcej informacji: Używanie współrzędnych Kotlin z komponentami architektury Androida

LiveData w architekturze aplikacji

LiveData uwzględnia cykl życia zgodnie z cyklem życia jednostek, takich jak aktywności i fragmentów. Do komunikacji między tymi cyklami życia używaj narzędzia LiveData właścicieli i inne obiekty o różnym okresie ważności, np. obiekty ViewModel. ViewModel odpowiada głównie za wczytywanie interfejsu użytkownika i zarządzanie nim dzięki czemu świetnie nadaje się do przechowywania obiektów LiveData. Utwórz LiveData obiektów w ViewModel i użyj ich do udostępniania stanu interfejsowi użytkownika warstwę.

Aktywności i fragmenty nie powinny zawierać LiveData instancji, ponieważ ich rola jest wyświetlanie danych, a nie wstrzymanie. Ponadto aktywność i fragmenty w filmie przed przechowywaniem danych, ułatwia pisanie testów jednostkowych.

Praca obiektów LiveData w klasie warstwy danych może wydawać się kusząca, LiveData nie służy do obsługi asynchronicznych strumieni danych. Mimo że możesz używać przekształceń LiveData i MediatorLiveData Aby to osiągnąć, takie podejście ma wady: możliwość łączenia strumieni. danych jest bardzo ograniczone, a wszystkie obiekty LiveData (w tym te utworzone) przez przekształcenia) są obserwowane w wątku głównym. Poniższy kod to jak przytrzymanie LiveData w Repository może zablokować główny wątek:

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

Jeśli musisz używać strumieni danych w innych warstwach aplikacji, rozważ za pomocą Kotlin Flows, a następnie konwertując je na LiveData w ViewModel za pomocą: asLiveData(). Aby dowiedzieć się więcej o korzystaniu z narzędzia Kotlin Flow w połączeniu z platformą LiveData, zapoznaj się z tym ćwiczeniem z programowania. W przypadku baz kodu utworzonych w języku Java rozważ użycie wykonawców. w połączeniu z wywołaniami zwrotnymi lub RxJava.

Rozszerz LiveData

LiveData uznaje obserwatora za aktywny, jeśli cyklu życia STARTED lub RESUMED stanów. Poniższy przykładowy kod ilustruje, jak rozszerzyć Zajęcia 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);
    }
}

Implementacja detektora cen w tym przykładzie obejmuje te elementy ważne metody:

  • onActive() jest wywoływana, gdy obiekt LiveData ma aktywnego obserwatora. Oznacza to, że musisz zacząć obserwować zmiany cen akcji za pomocą tej metody.
  • onInactive() jest wywoływana, gdy obiekt LiveData nie ma żadnych aktywnych obserwatorów. Żaden obserwator nie słucha, więc nie ma powodu, aby pozostawać w kontakcie StockManager.
  • setValue(T) aktualizuje wartość instancji LiveData i powiadamia wszystkie aktywne o tej zmianie.

klasy StockLiveData możesz używać w ten sposób:

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

observe() przechodzi przez LifecycleOwner z widokiem danego fragmentu jako pierwszy argument. Oznacza to, że ten obserwator jest powiązany z obiektem Lifecycle powiązane z właścicielem, co oznacza, że:

  • Jeśli obiekt Lifecycle nie jest w stanie aktywnym, oznacza to, że obserwator jest wywoływane nawet wtedy, gdy wartość ulegnie zmianie.
  • Po zniszczeniu obiektu Lifecycle obserwator jest automatycznie usunięto.

Obiekty LiveData są rozpoznawane zgodnie z cyklem życia, dzięki czemu możesz udostępniać i podział na wiele aktywności, fragmentów i usług. Aby zachować przykład możesz zastosować klasę LiveData jako pojedynczy element w ten sposób:

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

Możesz go też użyć we fragmencie w taki sposób:

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

Instancję MyPriceListener można obserwować przez wiele fragmentów i działań. LiveData łączy się z usługą systemową tylko wtedy, gdy co najmniej 1 z nich jest widoczny i aktywne.

Przekształcanie danych aktywnych

Warto zmienić wartość przechowywane w LiveData obiekt przed wysyłając ją do obserwatorów lub zwrócenie innego LiveData na podstawie wartości innej. Pakiet Lifecycle zapewnia Transformations , która zawiera metody pomocnicze obsługujące te scenariusze.

Transformations.map()
Stosuje funkcję na wartości zapisanej w obiekcie LiveData oraz rozpowszechni wynik niżej.

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()
Podobnie jak map(), stosuje funkcję do wartości zapisanej w tabeli LiveData oraz wyodrębnia i wysyła wynik poniżej. Funkcja przekazana funkcji switchMap() musi zwrócić obiekt LiveData, jak to przedstawiono w ten przykład:

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

Można użyć metod przekształcania do przenoszenia informacji w przestrzeni cyklu życia usługi. Przekształcenia nie są obliczane, jeśli obserwator nie patrzy zwrócony obiekt LiveData. Ponieważ przekształcenia są obliczane leniwe zachowanie związane z cyklem życia jest pośrednio przekazywane bez konieczności na dodatkowe bezpośrednie wywołania lub zależności.

Jeśli uważasz, że potrzebujesz obiektu Lifecycle w ViewModel jest prawdopodobnie lepszym rozwiązaniem. Załóżmy na przykład, że masz komponent interfejsu, który akceptuje adres i zwraca dla niego kod pocztowy, adresu. Możesz zaimplementować interfejs naiwny ViewModel dla tego komponentu jako widać w tym przykładowym kodzie:

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

Komponent interfejsu musi następnie wyrejestrować się z poprzedniego obiektu LiveData i zarejestrować się w nowej instancji za każdym razem, gdy wywołuje metodę getPostalCode(). W po odtworzeniu elementu UI uruchamia kolejne wywołanie funkcji repository.getPostCode() zamiast używać wyniku poprzedniego wywołania.

Zamiast tego możesz zaimplementować wyszukiwanie kodu pocztowego jako przekształcenie dane wejściowe, tak jak w tym przykładzie:

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

W tym przypadku pole postalCode jest zdefiniowane jako przekształcenie funkcji addressInput O ile Twoja aplikacja ma aktywnego obserwatora powiązanego z postalCode, wartość pola jest ponownie obliczana i pobierana za każdym razem, Zmiany: addressInput.

Ten mechanizm umożliwia niższe poziomy aplikacji tworzenie obiektów LiveData, które są obliczane leniwie na żądanie. Obiekt ViewModel można łatwo uzyskać odwołania do LiveData obiektów, a następnie zdefiniuj reguły przekształcania dla .

Utwórz nowe przekształcenia

Istnieje kilkanaście różnych specyficznych przekształceń, które mogą być przydatne aplikacji, ale nie są one domyślnie udostępniane. Aby przeprowadzić własną transformację MediatorLiveData klasy, która słucha innych LiveData obiektów i przetwarzania zdarzeń wywoływanych przez nie. Funkcja MediatorLiveData prawidłowo rozpowszechnia do źródłowego obiektu LiveData. Aby dowiedzieć się więcej o tym wzorcu, zobacz dokumentacji referencyjnej Transformations zajęcia.

Scalanie wielu źródeł LiveData

MediatorLiveData to podklasa LiveData, która pozwala scalić wiele źródeł LiveData. Obserwatorzy miejsca MediatorLiveData Obiekty są wywoływane za każdym razem, gdy dowolny z pierwotnych obiektów źródła LiveData .

Jeśli na przykład masz w interfejsie obiekt LiveData, który można zaktualizować z lokalnej bazy danych lub sieci, możesz dodać do raportu Obiekt MediatorLiveData:

  • Obiekt LiveData powiązany z danymi przechowywanymi w bazie danych.
  • Obiekt LiveData powiązany z danymi, do których dostęp jest uzyskiwany z sieci.

Wystarczy, że aktywność będzie obserwować obiekt MediatorLiveData, aby otrzymać informacje z obu źródeł. Szczegółowy przykład można znaleźć w Załączniku: ujawnianie stan sieci w Przewodniku po aplikacji Architektura.

Dodatkowe materiały

Aby dowiedzieć się więcej na temat: LiveData – konsultacja poniższe zasoby.

Próbki

Ćwiczenia z programowania

Blogi

Filmy

. .