LiveData'ya genel bakış Android Jetpack'in bir parçasıdır.

LiveData gözlemlenebilir bir veri sahibi sınıfını ifade eder. Normal gözlemlenebilir uygulamaların aksine LiveData, yaşam döngüsüne duyarlıdır. Diğer uygulama bileşenlerinin (ör. etkinlikler, alan) ve uygulama parçalar veya hizmetler. Bu farkındalık, LiveData'nın yalnızca uygulamayı güncellemesini sağlar etkin yaşam döngüsü durumda olan bileşen gözlemcileridir.

LiveData bir gözlemci olarak kabul edilir; bu gözlemci, Observer sınıfını kullanarak aktif durumda olduğu sürece STARTED veya RESUMED durumu. LiveData, yalnızca aktif gözlemcileri güncellemeler hakkında bilgilendirir. Etkin değil izlemek için kayıtlı gözlemciler LiveData nesne aynı değil bildirim alır.

Şunu uygulayan bir nesneyle eşlenmiş bir gözlemci kaydedebilirsiniz: LifecycleOwner kullanır. Bu ilişki, değişkenin durumu gerçekleştiğinde gözlemcinin ilgili Lifecycle nesne değişikliği - DESTROYED. Bu, özellikle etkinlikler ve parçalar için yararlıdır çünkü LiveData nesneyi gözlemleyin Böylece, sızıntıları dert etmeyin. Etkinlikler ve parçalar anında aboneliği iptal edilir.

LiveData'nın nasıl kullanılacağı hakkında daha fazla bilgi için LiveData ile çalışma nesneler'i tıklayın.

LiveData kullanmanın avantajları

LiveData'yı kullanmak aşağıdaki avantajları sağlar:

Kullanıcı arayüzünüzün, veri durumunuzla eşleştiğinden emin olur

LiveData, gözlemci kalıbını uygular. LiveData bildirim Şu durumda Observer nesne değişikliklerine neden olabilir. Kullanıcı arayüzünü güncellemek için kodunuzu bu Observer nesne algılandı. Bu şekilde, kullanıcı arayüzünü her Gözlemci bunu sizin için yapar, çünkü uygulama verileri değişir.

Bellek sızıntısı yok

Gözlemciler Lifecycle nesne ve ilişkili yaşam döngüleri yok edildikten sonra kendilerinden sonra temizlenecekler.

Durdurulan etkinlikler nedeniyle kilitlenme yok

Gözlemcinin yaşam döngüsü aktif değilse (örneğin, herhangi bir LiveData etkinliği almaz.

Yaşam döngüsü boyunca manuel işlem yapmanıza gerek yok

Kullanıcı arayüzü bileşenleri yalnızca alakalı verileri gözlemler ve gözlemi durdurmaz veya devam ettirmez. LiveData, canlı yayının önemli bir parçası olduğu için tüm bunları otomatik olarak yönetir yaşam döngüsü durumunun değişmesidir.

Her zaman güncel veriler

Bir yaşam döngüsü devre dışı kalırsa sonrasında en son verileri alır. yeniden etkin. Örneğin, arka plandaki bir etkinlik hemen arka planda görünmesi gerekir.

Uygun yapılandırma değişiklikleri

Bir etkinlik veya parça, hareket ettiğinde kullanılabilir en son verileri anında alır.

Kaynakları paylaşma

LiveData Böylece, sistem hizmetlerini sarmalamak için tekli kalıbı kullanan bir nesne uygulamanızda paylaşılanlar. LiveData nesnesi, sistem hizmetine bir kez bağlanır. Kaynağa ihtiyacı olan her gözlemci sadece LiveData videosunu izleyebilir nesnesini tanımlayın. Daha fazla bilgi için LiveData'yı genişletme konusuna bakın.

LiveData nesneleriyle çalışma

Aşağıdaki adımları uygulayarak LiveData nesne:

1. Belirli bir veri türünü barındırmak için bir LiveData örneği oluşturun. Bu genellikle bu süre içinde ViewModel sınıfı.
2. Bir Observer oluşturun onChanged() yöntemi (LiveData nesnesine ait veriler tutulduğunda ne olduğunu kontrol eder) anlamına gelir. Kullanıcı arayüzü denetleyicisinde genellikle şunun gibi bir Observer nesnesi oluşturursunuz: bir eylem veya parça olarak kavrayacaksınız.

3. Observer nesnesini, şunu kullanarak LiveData nesnesine ekleyin: observe() yöntemini kullanabilirsiniz. observe() yöntemi bir LifecycleOwner nesnesini tanımlayın. Bu işlem, Observer nesnesini LiveData nesnesine abone yapar ve böylece haberdar edilir. Observer nesnesini genelde Etkinlik veya parça gibi kullanıcı arayüzü denetleyicisi.

LiveData nesnesinde depolanan değeri güncellediğinizde tüm ekteki LifecycleOwner etkin olduğu sürece kayıtlı gözlemciler durumu.

LiveData, kullanıcı arayüzü denetleyici gözlemcilerinin güncellemelere abone olmasına olanak tanır. Veriler LiveData nesnesi değişiklikleri tarafından tutulduğunda kullanıcı arayüzü otomatik olarak güncellenir.

LiveData nesneleri oluşturma

LiveData, verilerinizi gösteren nesneler de dahil olmak üzere Collections (List gibi) uygulayın. CEVAP LiveData nesnesi genellikle ViewModel içinde depolanır aşağıda gösterildiği gibi bir alıcı yöntemi ile erişilir ve nesneye aşağıdaki gibi erişilebilir: örnek:

class NameViewModel : ViewModel() {

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

    // Rest of the ViewModel...
}

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

Başlangıçta, bir LiveData nesnesindeki veriler ayarlanmamıştır.

ViewModel dersinin avantajları ve kullanımı hakkında daha fazla bilgiyi şu sayfada bulabilirsiniz: ViewModel kılavuzu.

LiveData nesnelerini gözlemleme

Çoğu durumda, uygulama bileşeninin onCreate() yöntemi gözlemlemeye başlamak için doğru yerdir: LiveData nesnesi şu nedenlerle:

• Sistemin bir etkinlikten gereksiz aramalar yapmadığından emin olmak için parçanın onResume() yöntemini kullanır.
• Etkinliğin veya parçanın, en kısa sürede görüntüleyebileceği verilerin bulunduğundan emin olmak için etkin hale gelir. Bir uygulama bileşeni STARTED durumu, sahip olduğu LiveData nesneden en son değeri alır. gözlemleyeceğiz. Bu durum yalnızca gözlemlenecek LiveData nesnesi ayarlandı.

LiveData, güncellemeleri genellikle yalnızca veriler değiştiğinde ve yalnızca etkin olduğunda yayınlar. gözlemleyicileridir. Bu davranışın bir istisnası, gözlemcilerin aynı zamanda etkin değil durumundan etkin durumuna geçtiklerinde güncelleme yapar. Ayrıca, gözlemcinin etkin değil durumundan etkin durumuna ikinci kez geçmesi durumunda, yalnızca değer son etkin hale gelmesinden bu yana değiştiyse güncellenir.

Aşağıdaki örnek kod, LiveData gözlemlemeye nasıl başlayacağınızı göstermektedir nesne:

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

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

Şu tarihten sonra: observe() çağrıldı ve nameObserver şu şekilde geçti: parametresini onChanged() mCurrentName içinde depolanan en son değeri sağlayarak hemen çağrılır. LiveData nesnesi mCurrentName içinde bir değer ayarlamadıysa onChanged() çağrılmaz.

LiveData nesnelerini güncelleme

LiveData'da depolanan verileri güncellemek için herkese açık bir yöntem mevcut değildir. İlgili içeriği oluşturmak için kullanılan MutableLiveData sınıf, setValue(T) ve postValue(T) yöntemleri herkese açık olarak kullanabilir ve bu e-postada depolanan değeri düzenlemeniz veya LiveData nesnesidir. Genellikle MutableLiveData, ViewModel ve ardından ViewModel, gözlemcilere yalnızca sabit LiveData nesneleri gösterir.

Gözlemci ilişkisini kurduktan sonra bu değeri güncelleyebilirsiniz. aşağıdaki örnekte gösterildiği gibi LiveData nesnesinin Kullanıcı bir düğmeye dokunduğunda tüm gözlemcileri tetikler:

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

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

Örnekte setValue(T) çağrısı yapıldığında gözlemciler, onChanged() yöntemi için John Doe değerini kabul edersiniz. Örnekte bir düğmeye basılması gösterilmektedir, mName adlı çeşitli öğeleri güncellemek için setValue() veya postValue() çağrılabilir (ör. ağ isteğine veya veritabanı yüküne yanıt olarak) tamamlama; her durumda, setValue() veya postValue() çağrısı tetiklenir. ve kullanıcı arayüzünü günceller.

Room ile LiveData'yı kullan

Oda kalıcılık kitaplığının desteklediği döndüren gözlemlenebilir sorgular LiveData nesne. Gözlemlenebilir sorgular, Veritabanı Erişim Nesnesi'nin (DAO) parçası olarak yazılır.

Oda, aşağıdaki durumlarda LiveData nesnesini güncellemek için gerekli tüm kodu oluşturur: güncellenir. Oluşturulan kod, sorguyu eşzamansız olarak arka plan ileti dizisi oluşturabilirsiniz. Bu kalıp, verileri saklamaya devam etmek için veri tabanında depolanan verilerle senkronize bir şekilde görüntülenir. Web sitemiz g.co/newsinitiative/labs üzerinden Oda kalıcı kitaplığındaki Oda ve DAO'lar hakkında rehberini inceleyin.

LiveData ile eş yordamları kullanma

LiveData, Kotlin eş yordamlarını destekler. Daha fazla bilgi için bkz. Android Mimari Bileşenleri ile Kotlin eş yordamlarını kullanın.

Uygulamanın mimarisinde LiveData

LiveData, şu gibi varlıkların yaşam döngüsünü takip ederek yaşam döngüsüne duyarlıdır: parçalardan bahsedeceğiz. Bu yaşam döngüleri arasında iletişim kurmak için LiveData kullanın sahipler ve farklı ömürleri olan diğer nesneler (ör. ViewModel nesneler). ViewModel öğesinin ana sorumluluğu, kullanıcı arayüzü ile ilgili öğeleri yükleyip yönetmektir. bu nedenle LiveData nesneleri barındırmak için mükemmel bir aday olabilir. İçerik üretme ViewModel içinde LiveData nesne var ve bunları kullanıcı arayüzüne göstermek için kullanın katmanıdır.

Etkinlikler ve parçalar, rolleri nedeniyle LiveData örnekleri tutmamalıdır durumu değil verileri görüntülemektir. Ayrıca, etkinlikleri ve parçaları ücretsiz tutmak için, birim testlerini yazmayı kolaylaştırır.

Veri katmanı sınıfınızda LiveData nesnelerini kullanmak cazip gelebilir, ancak LiveData, eşzamansız veri akışlarını işleyecek şekilde tasarlanmamıştır. Her ne kadar LiveData dönüşüm ve MediatorLiveData kullanabilirsiniz Bu yaklaşımın dezavantajları vardır: akışları ve LiveData nesnenin (oluşturulanlar dahil) tümü çok sınırlı ve dönüşümler) ana iş parçacığında gözlemlenir. Aşağıdaki kod Repository içinde LiveData tutmanın ana sayfayı nasıl engelleyebileceğine dair örnek ileti dizisi:

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

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

Veri akışlarını uygulamanızın diğer katmanlarında kullanmanız gerekiyorsa aşağıdakileri göz önünde bulundurun: Kotlin Akışları kullanarak ve ardından bunları LiveData asLiveData() kullanılarak ViewModel. LiveData ile Kotlin Flow kullanımı hakkında daha fazla bilgi edinmek için bu codelab'e göz atın. Java ile oluşturulan kod tabanları için Yürütücüler kullanabilirsiniz. ve RxJava ile birlikte kullanılabilir.

LiveData'yı Genişlet

Gözlemcinin durumu başarılıysa LiveData gözlemciyi etkin durumda kabul eder ya da sürecin STARTED veya RESUMED eyaletler. Aşağıdaki örnek kod, LiveData sınıf:

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

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

Bu örnekteki fiyat işleyicinin uygulanması şunları içerir: önemlidir:

• onActive() yöntemi, LiveData nesnesi etkin bir gözlemciye sahip olduğunda çağrılır. Bunun anlamı şudur: bu yöntemle hisse senedi fiyatı güncellemelerini incelemeye başlamanız gerekir.
• onInactive() yöntemi, LiveData nesnesinde etkin gözlemci olmadığında çağrılır. Hiçbir gözlemci dinlemediği için StockManager hizmeti.
• setValue(T) yöntemi, LiveData örneğinin değerini günceller ve etkin durumdaki kullanıcıları gözlemcilerle iletişim kurmaktır.

StockLiveData sınıfını aşağıdaki şekilde kullanabilirsiniz:

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

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

İlgili içeriği oluşturmak için kullanılan observe() yöntemi LifecycleOwner ilk bağımsız değişken olarak parçanın görünümüyle ilişkilendirilir. Bu, ekibinizin bu gözlemci Lifecycle nesnesine bağlı ile ilişkilidir; yani:

• Lifecycle nesnesi etkin durumda değilse gözlemci değildir çağrılmasını sağlayın.
• Lifecycle nesnesi kaldırıldıktan sonra gözlemci otomatik olarak emin olun.

LiveData nesnelerin yaşam döngüsüne duyarlı olması sayesinde ürün, parça ve hizmet arasında boşluksuz bir şekilde çalışır. Örneği korumak için basitçe, LiveData sınıfını aşağıdaki gibi bir singleton olarak uygulayabilirsiniz:

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

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

Ayrıca, bunu parça içinde aşağıdaki şekilde kullanabilirsiniz:

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

    }

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

Birden fazla parça ve etkinlik, MyPriceListener örneğini gözlemleyebilir. LiveData, sistem hizmetine yalnızca biri veya daha fazlası görünür durumdaysa bağlanır ve etkin durumda olduğundan emin olun.

LiveData'yı dönüştürme

Şurada depolanan değerde değişiklik yapmak isteyebilirsiniz: Önce LiveData nesne bunu gözlemcilere gönderebilir veya farklı bir Başka bir öğenin değerine bağlı olarak LiveData örneği. İlgili içeriği oluşturmak için kullanılan Lifecycle paketi sağlar Transformations destekleyici yöntemler içeren bir sınıf oluşturun.

Transformations.map()

LiveData nesnesinde depolanan değere bir işlev uygular ve sonuç aşağı akışa yayar.

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

LiveData<User> userLiveData = ...;
LiveData<String> userName = Transformations.map(userLiveData, user -> {
    user.name + " " + user.lastName
});

Transformations.switchMap()

map() işlevine benzer şekilde, LiveData içinde depolanan değere bir işlev uygular nesnesinin sarmalamasını açıp aşağı akışa gönderir. İşlev to switchMap(), LiveData şu örneği inceleyin:

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

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

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

Gözlemcinin cihazında bilgi aktarmak için dönüştürme yöntemlerini kullanabilirsiniz yaşam döngüsü boyunca geçerlidir. Bir gözlemci izlemediği sürece dönüşümler hesaplanmaz döndürülen LiveData nesnesini tanımlayın. Çünkü dönüşümler hesaplandığında yaşam döngüsüyle ilgili davranış, herhangi bir işlem gerekmeden veya bağımlılıkları belirlemenize yardımcı olur.

Bir Lifecycle nesnesine ihtiyacınız olduğunu düşünüyorsanız ViewModel nesnesi, bir muhtemelen daha iyi bir çözümdür. Örneğin, 2023 Yılbaşı İndirimi adında adresi kabul eden ve bunun için posta kodunu döndüren bir kullanıcı arayüzü bileşeni girin. Bu bileşen için naif ViewModel öğesini aşağıdaki örnek kodla gösterilmektedir:

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

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

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

Daha sonra kullanıcı arayüzü bileşeninin önceki LiveData nesnesindeki kaydı iptal etmesi gerekir ve getPostalCode() çağrısında her seferinde yeni örneğe kaydolun. İçinde kullanıcı arayüzü bileşeni yeniden oluşturulursa, repository.getPostCode() yöntemini çağırın.

Bunun yerine, posta kodu aramasını aşağıdaki örnekte gösterildiği gibi adres girişi:

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

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

Bu durumda postalCode alanı, addressInput. Uygulamanız Google Analytics 4 ile ilişkili etkin bir gözlemci postalCode alanına girildiğinde, alanın değeri yeniden hesaplanır ve addressInput değişiklik.

Bu mekanizma, uygulamanın daha alt düzeylerindeki LiveData nesnelerin oluşturulmasına olanak tanır. ancak talep üzerine gecikmeli olarak hesaplanır. Bir ViewModel nesnesi kolayca alınabilir LiveData nesne için referanslar oluşturabilir ve ardından bu nesnelere gerekir.

Yeni dönüşümler oluşturma

İşletmenizde yararlı olabilecek bir düzine farklı dönüşüm ancak bu özellikler varsayılan olarak sağlanmaz. Kendi dönüşümünüzü uygulamak için MediatorLiveData aracını kullanabilirsiniz başkalarını dinleyen bir sınıf LiveData nesne ve nasıl işlediğini ifade eder. MediatorLiveData, durumu LiveData nesnesine gönderilir. Bu kalıp hakkında daha fazla bilgi için referans belgeleri, Transformations sınıfını kullanır.

Birden fazla LiveData kaynağını birleştirme

MediatorLiveData LiveData alt sınıfının birden fazla LiveData kaynağını birleştirmenize olanak tanır. MediatorLiveData gözlemcileri daha sonra orijinal LiveData kaynak nesnelerinden herhangi biri unutmayın.

Örneğin, kullanıcı arayüzünüzdeLiveData ağ kullanıyorsanız aşağıdaki kaynakları MediatorLiveData nesne:

• Veritabanında depolanan verilerle ilişkili bir LiveData nesnesi.
• Ağdan erişilen verilerle ilişkili bir LiveData nesnesi.

Etkinliğinizin alması için yalnızca MediatorLiveData nesnesini gözlemlemesi yeterlidir güncelleme de yapıyoruz. Ayrıntılı bir örnek için Addendum: exposing ağ durumu Uygulama Kılavuzu'nun Mimari.

Ek kaynaklar

LiveData ders, danışma inceleyebilirsiniz.

Örnekler

• gösteren bir demo uygulaması olan Sunflower, Mimari Bileşenleri
• Android Mimari Bileşenleri Temel Örneği

Codelab'ler

• Manzaralı Android Odası (Java) (Kotlin)
• Kotlin Flow ve LiveData ile gelişmiş eş yordamları öğrenin

Bloglar

• ViewModels ve LiveData: Kalıplar + Anti Kalıplar
• ViewModel'in ötesinde LiveData: Dönüşümler kullanan reaktif kalıplar ve MediatorLiveData
• SnackBar, Navigasyon ve diğer etkinlikler ile LiveData (SingleLiveEvent destek kaydı)

Videolar

• Jetpack LiveData
• LiveData ile eğlence (Android Dev Summit '18)