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

LiveData, gözlemlenebilir bir veri tutucu sınıfıdır. Normal bir gözlemlenebilirin aksine LiveData, yaşam döngüsü bilincine sahiptir. Yani etkinlikler, parçalar veya hizmetler gibi diğer uygulama bileşenlerinin yaşam döngüsüne uyar. Bu farkındalık, LiveData'nın yalnızca etkin yaşam döngüsü durumundaki uygulama bileşeni gözlemcilerini güncellemesini sağlar.

LiveData, yaşam döngüsü STARTED veya RESUMED durumunda olan Observer sınıfıyla temsil edilen bir gözlemcinin etkin durumda olduğunu düşünür. LiveData yalnızca etkin gözlemcileri güncellemeler hakkında bilgilendirir. LiveData nesnelerini izlemek için kayıtlı olan etkin olmayan gözlemcilere değişikliklerle ilgili bildirim gönderilmez.

LifecycleOwner arayüzünü uygulayan bir nesneyle eşleştirilmiş bir gözlemci kaydedebilirsiniz. Bu ilişki, ilgili Lifecycle nesnesinin durumu DESTROYED olarak değiştiğinde gözlemcinin kaldırılmasına olanak tanır. Bu, özellikle etkinlikler ve parçalar için kullanışlıdır. Çünkü LiveData nesnelerini güvenli bir şekilde gözlemleyebilir ve sızıntı konusunda endişelenmezler. Etkinlikler ve parçalar, yaşam döngüleri yok edildiğinde abonelikten anında çıkarılır.

LiveData'nın nasıl kullanılacağı hakkında daha fazla bilgi için LiveData nesneleriyle çalışma bölümüne bakın.

LiveData'yı kullanmanın avantajları

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

Kullanıcı arayüzünüzün veri durumunuzla eşleşmesini sağlar

LiveData, gözlemci kalıbını izler. LiveData, temel veriler değiştiğinde Observer nesnelerini bilgilendirir. Bu Observer nesnelerindeki kullanıcı arayüzünü güncellemek için kodunuzu birleştirebilirsiniz. Bu sayede, gözlemci sizin için bu işlemi yaptığından uygulama verileri her değiştiğinde kullanıcı arayüzünü güncellemeniz gerekmez.

Bellek sızıntısı yok

Gözlemciler, Lifecycle nesnelerine bağlıdır ve ilişkili yaşam döngüsü yok edildiğinde kendilerinden sonra temizlik yapar.

Durdurulan etkinlikler nedeniyle kilitlenme yok

Gözlemcinin yaşam döngüsü etkin değilse (ör. arka yığıntaki bir etkinlik söz konusuysa) LiveData etkinliği almaz.

Artık yaşam döngülerini manuel olarak yönetmenize gerek yok

Kullanıcı arayüzü bileşenleri yalnızca alakalı verileri gözlemler ve gözlemi durdurmaz veya devam ettirmez. LiveData, gözlem sırasında ilgili yaşam döngüsü durumu değişikliklerinden haberdar olduğu için tüm bunları otomatik olarak yönetir.

Her zaman güncel veriler

Bir yaşam döngüsü devre dışı kalırsa yeniden etkinleştirildiğinde en son verileri alır. Örneğin, arka planda olan bir etkinlik ön plana döndükten hemen sonra en son verileri alır.

Doğru yapılandırma değişiklikleri

Bir etkinlik veya parça, cihaz döndürme gibi bir yapılandırma değişikliği nedeniyle yeniden oluşturulursa mevcut en son verileri hemen alır.

Kaynakları paylaşma

Sistem hizmetlerini uygulamanızda paylaşılabilmesi için sarmalamak üzere tekil kalıbı kullanarak bir LiveData nesnesini genişletebilirsiniz. LiveData nesnesi sistem hizmetine bir kez bağlanır ve ardından kaynağa ihtiyaç duyan tüm gözlemciler LiveData nesnesini izleyebilir. Daha fazla bilgi için LiveData'yı genişletme başlıklı makaleyi inceleyin.

LiveData nesneleriyle çalışma

LiveData nesneleriyle çalışmak için aşağıdaki adımları uygulayın:

1. Belirli bir veri türünü saklamak için LiveData örneği oluşturun. Bu işlem genellikle ViewModel sınıfınızda yapılır.
2. LiveData nesnesinin tutulan verileri değiştiğinde ne olacağını kontrol eden onChanged() yöntemini tanımlayan bir Observer nesnesi oluşturun. Genellikle kullanıcı arayüzü denetleyicisinde bir Observer nesnesi (ör. etkinlik veya parça) oluşturursunuz.

3. observe() yöntemini kullanarak Observer nesnesini LiveData nesnesine ekleyin. observe() yöntemi bir LifecycleOwner nesnesi alır. Bu işlem, Observer nesnesini LiveData nesnesine abone ederek değişikliklerden haberdar olmasını sağlar. Observer nesnesini genellikle bir kullanıcı arayüzü denetleyicisine (ör. etkinlik veya parça) eklersiniz.

LiveData nesnesinde depolanan değeri güncellediğinizde, bağlı LifecycleOwner etkin durumda olduğu sürece kayıtlı tüm gözlemcileri tetikler.

LiveData, kullanıcı arayüzü denetleyici gözlemcilerinin güncellemelere abone olmasına olanak tanır. LiveData nesnesi tarafından tutulan veriler değiştiğinde kullanıcı arayüzü buna yanıt olarak otomatik olarak güncellenir.

LiveData nesneleri oluşturma

LiveData, Collections'yi uygulayan nesneler (ör. List) dahil olmak üzere tüm verilerle kullanılabilen bir sarmalayıcıdır. LiveData nesnesi genellikle bir ViewModel nesnesinde saklanır ve aşağıdaki örnekte gösterildiği gibi bir alıcı yöntemi aracılığıyla erişilir:

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, LiveData nesnesinde veriler ayarlanmamıştır.

ViewModel sınıfının avantajları ve kullanımı hakkında daha fazla bilgiyi ViewModel kılavuzunda bulabilirsiniz.

LiveData nesnelerini gözlemleme

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

• Sistemin bir etkinlik veya parçanın onResume() yönteminden gereksiz çağrılar yapmamasını sağlamak için.
• Etkinlik veya parçanın etkin hale gelir gelmez gösterebileceği verilere sahip olmasını sağlamak için. Bir uygulama bileşeni STARTED durumuna girer girmez, gözlemlediği LiveData nesnelerinden en son değeri alır. Bu durum yalnızca gözlemlenecek LiveData nesnesi ayarlanmışsa ortaya çıkar.

LiveData genellikle yalnızca veriler değiştiğinde ve yalnızca etkin gözlemcilere güncellemeler sunar. Bu davranışın istisnası, gözlemciler etkin olmayan durumdan etkin duruma geçtiklerinde de güncelleme almalarıdır. Ayrıca, gözlemci etkin olmayandan etkin duruma ikinci kez geçerse yalnızca değer, etkin olduğu son zamandan beri değiştiyse güncelleme alır.

Aşağıdaki örnek kodda, bir LiveData nesnesinin nasıl gözlemlenmeye başlayacağı gösterilmektedir:

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

observe(), parametre olarak nameObserver ile çağrıldıktan sonra 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 yöntemler yoktur. MutableLiveData sınıfı, setValue(T) ve postValue(T) yöntemlerini herkese açık olarak gösterir. LiveData nesnesinde depolanan değeri düzenlemeniz gerekiyorsa bu yöntemleri kullanmanız gerekir. Genellikle ViewModel içinde MutableLiveData kullanılır ve ardından ViewModel, gözlemcilere yalnızca değiştirilemeyen LiveData nesnelerini gösterir.

Gözlemci ilişkisini ayarladıktan sonra, aşağıdaki örnekte gösterildiği gibi LiveData nesnesinin değerini güncelleyebilirsiniz. Bu örnekte, kullanıcı bir düğmeye dokunduğunda tüm gözlemciler tetiklenir:

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ıldığında gözlemciler onChanged() yöntemlerini John Doe değeriyle çağırır. Örnekte bir düğmeye basılması gösterilmektedir ancak setValue() veya postValue(), bir ağ isteği veya veritabanı yüklemesinin tamamlanmasına yanıt olarak da dahil olmak üzere çeşitli nedenlerle mName'yi güncellemek için çağrılabilir. Her durumda, setValue() veya postValue() çağrısı gözlemcileri tetikler ve kullanıcı arayüzünü günceller.

LiveData'yı Room ile kullanma

Room kalıcılık kitaplığı, LiveData nesneleri döndüren gözlemlenebilir sorguları destekler. Gözlemlenebilir sorgular, veritabanı erişim nesnesi (DAO) kapsamında yazılır.

Room, bir veritabanı güncellendiğinde LiveData nesnesini güncellemek için gerekli tüm kodu oluşturur. Oluşturulan kod, gerektiğinde sorguyu arka plan iş parçacığında eşzamansız olarak çalıştırır. Bu kalıp, kullanıcı arayüzünde görüntülenen verilerin veritabanında depolanan verilerle senkronize olmasını sağlamak için yararlıdır. Room ve DAO'lar hakkında daha fazla bilgiyi Room kalıcı kitaplığı kılavuzunda bulabilirsiniz.

LiveData ile coroutine'leri kullanma

LiveData, Kotlin coroutine'leri için destek içerir. Daha fazla bilgi için Android mimari bileşenleriyle Kotlin eşzamanlı programlama yapılarını kullanma başlıklı makaleyi inceleyin.

Uygulama mimarisinde LiveData

LiveData, etkinlikler ve parçalar gibi öğelerin yaşam döngüsünü takip ederek yaşam döngüsü bilincine sahiptir. Bu yaşam döngüsü sahipleriyle ViewModel nesneleri gibi farklı bir yaşam süresine sahip diğer nesneler arasında iletişim kurmak için LiveData'ü kullanın. ViewModel'ün birincil sorumluluğu, kullanıcı arayüzüyle ilgili verileri yükleyip yönetmek olduğundan LiveData nesnelerini barındırmak için mükemmel bir adaydır. ViewModel içinde LiveData nesneleri oluşturun ve bunları kullanıcı arayüzü katmanına durum göstermek için kullanın.

Etkinlikler ve parçalar, durum tutmak yerine verileri görüntülemek için tasarlandığından LiveData örnekleri tutmamalıdır. Ayrıca, etkinlikleri ve parçaları veri içermeyecek şekilde tutmak birim testlerini yazmayı kolaylaştırır.

Veri katmanı sınıfınızda LiveData nesneleriyle çalışmak cazip gelebilir ancak LiveData, asenkron veri akışlarını işlemek için tasarlanmamıştır. Bunu yapmak için LiveData dönüşümlerini ve MediatorLiveData kullanabilseniz de bu yaklaşımın dezavantajları vardır: Veri akışlarını birleştirme özelliği çok sınırlıdır ve tüm LiveData nesneleri (dönüşümler aracılığıyla oluşturulanlar dahil) ana iş parçacığında gözlemlenir. Aşağıdaki kod, Repository içinde bir LiveData tutmanın ana mesaj dizisini nasıl engelleyebileceğine dair bir örnektir:

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

Uygulamanızın diğer katmanlarında veri akışları kullanmanız gerekiyorsa Kotlin akışlarını kullanıp bunları ViewModel içinde asLiveData() kullanarak LiveData olarak dönüştürebilirsiniz. Kotlin Flow'ü LiveData ile kullanma hakkında daha fazla bilgiyi bu codelab'de bulabilirsiniz. Java ile oluşturulan kod tabanları için geri çağırma veya RxJava ile birlikte Executors'ı kullanmayı deneyin.

LiveData'yı genişletme

LiveData, gözlemcinin yaşam döngüsü STARTED veya RESUMED durumlarındaysa gözlemcinin etkin durumda olduğunu düşünür. Aşağıdaki örnek kodda, LiveData sınıfının nasıl genişletileceği gösterilmektedir:

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 örnekte fiyat dinleyicisinin uygulanması aşağıdaki önemli yöntemleri içerir:

• LiveData nesnesi etkin bir gözlemciye sahip olduğunda onActive() yöntemi çağrılır. Bu, hisse fiyatı güncellemelerini bu yöntemden izlemeye başlamanız gerektiği anlamına gelir.
• onInactive() yöntemi, LiveData nesnesinin etkin gözlemcisi olmadığında çağrılır. Dinleyici olmadığı için StockManager hizmetine bağlı kalmanıza gerek yoktur.
• setValue(T) yöntemi, LiveData örneğinin değerini günceller ve etkin gözlemcileri değişiklik hakkında bilgilendirir.

StockLiveData sınıfını aşağıdaki gibi 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.
        });
    }
}

observe() yöntemi, ilk bağımsız değişken olarak parçanın görünümüyle ilişkili LifecycleOwner değerini iletir. Bu işlem, bu gözlemcinin sahiple ilişkili Lifecycle nesnesine bağlı olduğunu gösterir. Yani:

• Lifecycle nesnesi etkin durumda değilse değer değişse bile gözlemci çağrılmaz.
• Lifecycle nesnesi yok edildikten sonra gözlemci otomatik olarak kaldırılır.

LiveData nesnelerinin yaşam döngüsü bilincine sahip olması, bunları birden fazla etkinlik, parça ve hizmet arasında paylaşabileceğiniz anlamına gelir. Örneği basit tutmak için LiveData sınıfını aşağıdaki gibi tekil 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);
    }
}

Bu özelliği, aşağıdaki gibi parçada 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 yalnızca bunlardan biri veya daha fazlası görünür ve etkinse sistem hizmetine bağlanır.

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

Gözlemcilere göndermeden önce bir LiveData nesnesinde depolanan değerde değişiklik yapmak isteyebilirsiniz veya başka bir nesnenin değerine göre farklı bir LiveData örneği döndürmeniz gerekebilir. Lifecycle paketi, bu senaryoları destekleyen yardımcı yöntemleri içeren Transformations sınıfını sağlar.

Transformations.map()

LiveData nesnesinde depolanan değere bir işlev uygular ve sonucu aşağı akışa iletir.

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()'a benzer şekilde, LiveData nesnesinde depolanan değere bir işlev uygular ve sonucu alt akışa gönderir. switchMap() işlevine iletilen işlev, aşağıdaki örnekte gösterildiği gibi bir LiveData nesnesi döndürmelidir:

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

Bilgileri gözlemcinin yaşam döngüsü boyunca taşımak için dönüştürme yöntemlerini kullanabilirsiniz. Dönüşümler, döndürülen LiveData nesnesini izleyen bir gözlemci olmadığı sürece hesaplanmaz. Dönüşümler yavaşça hesaplandığından yaşam döngüsü ile ilgili davranış, ek açık çağrılar veya bağımlılıklar gerektirmeden dolaylı olarak aktarılır.

ViewModel nesnesi içinde bir Lifecycle nesnesine ihtiyacınız olduğunu düşünüyorsanız dönüşüm muhtemelen daha iyi bir çözümdür. Örneğin, bir adres kabul eden ve bu adresin posta kodunu döndüren bir kullanıcı arayüzü bileşeniniz olduğunu varsayalım. Bu bileşen için saf ViewModel'ü aşağıdaki örnek kodda gösterildiği gibi uygulayabilirsiniz:

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

Ardından kullanıcı arayüzü bileşeninin, önceki LiveData nesnesinin kaydını iptal etmesi ve getPostalCode()'u her çağırdığında yeni örneği kaydettirmesi gerekir. Ayrıca, kullanıcı arayüzü bileşeni yeniden oluşturulursa önceki çağrının sonucunu kullanmak yerine repository.getPostCode() yöntemine başka bir çağrı tetikler.

Bunun yerine, posta kodu aramasını aşağıdaki örnekte gösterildiği gibi adres girişinin bir dönüşümü olarak uygulayabilirsiniz:

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 alanının bir dönüşümü olarak tanımlanır. Uygulamanızda postalCode alanıyla ilişkili etkin bir gözlemci olduğu sürece, postalCode değiştiğinde alanın değeri yeniden hesaplanır ve alınır.addressInput

Bu mekanizma, uygulamanın alt düzeylerinin isteğe bağlı olarak yavaşça hesaplanan LiveData nesneleri oluşturmasına olanak tanır. ViewModel nesneleri, LiveData nesnelerine kolayca referans alabilir ve ardından bu nesnelerin üzerine dönüşüm kuralları tanımlayabilir.

Yeni dönüşümler oluşturma

Uygulamanızda yararlı olabilecek ancak varsayılan olarak sağlanmayan onlarca farklı dönüşüm vardır. Kendi dönüşümünüzü uygulamak için diğer LiveData nesnelerini dinleyen ve bu nesneler tarafından yayınlanan etkinlikleri işleyen MediatorLiveData sınıfını kullanabilirsiniz. MediatorLiveData, durumunu kaynak LiveData nesnesine doğru şekilde iletir. Bu kalıp hakkında daha fazla bilgi edinmek için Transformations sınıfının referans dokümanlarına bakın.

Birden fazla LiveData kaynağını birleştirme

MediatorLiveData, birden fazla LiveData kaynağını birleştirmenize olanak tanıyan LiveData sınıfının alt sınıfıdır. Ardından, orijinal LiveData kaynak nesnelerinden herhangi biri değiştiğinde MediatorLiveData nesnelerinin gözlemcileri tetiklenir.

Örneğin, kullanıcı arayüzünüzde yerel bir veritabanından veya ağdan güncellenebilecek bir LiveData nesneniz varsa MediatorLiveData nesnesine aşağıdaki kaynakları ekleyebilirsiniz:

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

Etkinliğinizin, her iki kaynaktan da güncelleme almak için yalnızca MediatorLiveData nesnesini gözlemlemesi gerekir. Ayrıntılı bir örnek için Uygulama Mimarisi Kılavuzu'nun Eki: Ağ durumunu gösterme bölümüne bakın.

Ek kaynaklar

LiveData sınıfı hakkında daha fazla bilgi edinmek için aşağıdaki kaynaklara göz atın.

Örnekler

• Mimari Bileşenleri ile ilgili en iyi uygulamaları gösteren demo uygulama Sunflower

Codelab uygulamaları

• Android Room with a View (Java) (Kotlin)
• Kotlin Flow ve LiveData ile gelişmiş eş yordamlar hakkında bilgi edinin

Bloglar

• ViewModels ve LiveData: Kalıplar + AntiKalıplar
• ViewModel'un ötesinde LiveData: Dönüşümler ve MediatorLiveData kullanan reaktif kalıplar
• SnackBar, gezinme ve diğer etkinliklerle LiveData (SingleLiveEvent örneği)

Videolar

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