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 buObserver
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 sadeceLiveData
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:
- Belirli bir veri türünü barındırmak için bir
LiveData
örneği oluşturun. Bu genellikle bu süre içindeViewModel
sınıfı. - Bir
Observer
oluşturunonChanged()
yöntemi (LiveData
nesnesine ait veriler tutulduğunda ne olduğunu kontrol eder) anlamına gelir. Kullanıcı arayüzü denetleyicisinde genellikle şunun gibi birObserver
nesnesi oluşturursunuz: bir eylem veya parça olarak kavrayacaksınız. Observer
nesnesini, şunu kullanarakLiveData
nesnesine ekleyin:observe()
yöntemini kullanabilirsiniz.observe()
yöntemi birLifecycleOwner
nesnesini tanımlayın. Bu işlem,Observer
nesnesiniLiveData
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:
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... }
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ğuLiveData
nesneden en son değeri alır. gözlemleyeceğiz. Bu durum yalnızca gözlemlenecekLiveData
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:
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); } }
Ş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:
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); } });
Ö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:
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())); } }
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:
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); } }
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çinStockManager
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:
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. }); } }
İ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:
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); } }
Ayrıca, bunu parça içinde aşağıdaki şekilde kullanabilirsiniz:
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. }); } }
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.
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()
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 toswitchMap()
,LiveData
şu örneği inceleyin:
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) );
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:
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); } }
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:
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); } }
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
ziyaret edin.Sizin için önerilenler
- Not: JavaScript kapalıyken bağlantı metni gösterilir
- Yaşam döngüsüne duyarlı bileşenlerle Kotlin eş yordamlarını kullanma
- Yaşam Döngüsüne Duyarlı Bileşenlerle Yaşam Döngülerini Yönetme
- Sayfalama uygulamanızı test etme