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

LiveData gözlemlenebilir bir veri sahibi sınıfıdır. Normal bir gözlemlenebilir özelliğin aksine LiveData yaşam döngüsüne duyarlıdır; 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ü durumunda olan uygulama bileşeni gözlemcilerini güncellemesini sağlar.

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

LifecycleOwner arayüzünü uygulayan bir nesneyle eşlenmiş bir gözlemci kaydedebilirsiniz. Bu ilişki, karşılık gelen Lifecycle nesnesinin durumu DESTROYED olarak değiştiğinde gözlemcinin kaldırılmasına olanak tanır. Bu özellik, LiveData nesnelerini güvenli bir şekilde gözlemleyebilecekleri ve sızıntılar konusunda endişelenmelerine gerek olmadığı için etkinlikler ve parçalar için özellikle yararlıdır. Böylece, yaşam döngüleri yok edildiğinde etkinlikler ve parçalar anında iptal edilir.

LiveData'nın nasıl kullanılacağı hakkında daha fazla bilgi için LiveData nesneleriyle çalışma konusuna bakı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şmesini sağlar
LiveData, gözlemci kalıbına göre hareket eder. LiveData, temel veri değişiklikleri sırasında Observer nesnelerini bilgilendirir. Kullanıcı arayüzünü bu Observer nesnede güncellemek için kodunuzu birleştirebilirsiniz. Böylece, uygulama verileri her değiştiğinde kullanıcı arayüzünü güncellemeniz gerekmez çünkü gözlemci bunu sizin için yapar.
Bellek sızıntısı yok
Gözlemciler Lifecycle nesnelerine bağlıdır ve ilişkili yaşam döngüleri yok edildiğinde bunları temizlemeleri gerekir.
Durdurulan etkinlikler nedeniyle kilitlenme yok
Gözlemcinin yaşam döngüsü etkin değilse (ör. arka yığındaki etkinliklerde) herhangi bir LiveData etkinliği almaz.
Yaşam döngüsünü manuel olarak işlemeye gerek yok
Kullanıcı arayüzü bileşenleri yalnızca alakalı verileri gözlemler ve gözlemi durdurmaz veya devam ettirmez. LiveData, gözlemler sırasında ilgili yaşam döngüsü durum değişikliklerinin farkında olduğundan tüm bunları otomatik olarak yönetir.
Her zaman güncel veriler
Bir yaşam döngüsü etkin değil hale gelirse tekrar etkin hale geldikten sonra en son verileri alır. Örneğin, arka planda olan bir etkinlik en son verileri ön plana döndükten hemen sonra alır.
Uygun yapılandırma değişiklikleri
Bir etkinlik veya parça, cihaz rotasyonu gibi bir yapılandırma değişikliği nedeniyle yeniden oluşturulursa hemen en son verileri alır.
Kaynakları paylaşma
Bir LiveData nesnesini, uygulamanızda paylaşılabilecek şekilde sarmalamak için tekilleştirme kalıbını kullanarak genişletebilirsiniz. LiveData nesnesi sistem hizmetine bir kez bağlanır ve daha sonra kaynağa ihtiyaç duyan herhangi bir gözlemci, yalnızca LiveData nesnesini izleyebilir. Daha fazla bilgi için LiveData'yı genişletme konusuna bakın.

LiveData nesneleriyle çalışma

LiveData nesneleriyle çalışmak için şu adımları uygulayın:

  1. Belirli türde verileri barındırmak için bir LiveData örneği oluşturun. Bu işlem genellikle ViewModel sınıfınızda yapılır.
  2. onChanged() yöntemini tanımlayan bir Observer nesnesi oluşturun. Bu yöntem, LiveData nesnesinin muhafaza edilen verileri değiştiğinde ne olacağını kontrol eder. Genellikle kullanıcı arayüzü denetleyicisinde etkinlik veya parça gibi bir Observer nesnesi 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 yaparak değişiklikler hakkında bildirim alır. Observer nesnesini genellikle etkinlik veya parça gibi bir kullanıcı arayüzü denetleyicisine eklersiniz.

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

LiveData, kullanıcı arayüzü denetleyicilerinin güncellemelere abone olmasına olanak tanır. LiveData nesnesinin barındırdığı veriler değiştiğinde kullanıcı arayüzü de buna göre otomatik olarak güncellenir.

LiveData nesneleri oluşturma

LiveData, List gibi Collections uygulayan nesneler dahil olmak üzere tüm verilerle kullanılabilecek bir sarmalayıcıdır. Aşağıdaki örnekte gösterildiği gibi, LiveData nesnesi genellikle ViewModel nesnesi içinde depolanır ve bu nesneye bir alıcı yöntemiyle erişilir:

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 LiveData nesnesindeki 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 nedenlerden dolayı 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örüntüleyebileceği verilere sahip olduğundan emin olmak için. Bir uygulama bileşeni STARTED durumunda olur olmaz gözlemlediği LiveData nesnelerinden en yeni değeri alır. Bu durum yalnızca, gözlemlenecek LiveData nesnesi ayarlanmışsa gerçekleşir.

LiveData genellikle yalnızca veri değiştiğinde ve yalnızca etkin gözlemcilere güncelleme yayınlar. Bu davranışın bir istisnası, gözlemcilerin etkin değil durumundan etkin duruma geçtiklerinde de güncelleme almasıdır. Ayrıca, gözlem sunucusunun "etkin değil" durumundan ikinci kez etkin durumuna geçmesi durumunda, yalnızca değer son etkin hale geldiğinden bu yana değiştiyse bir güncelleme alır.

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

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

Parametre olarak nameObserver iletilmiş olarak observe() çağrıldıktan sonra, mCurrentName içinde depolanan en son değeri sağlamak üzere onChanged() hemen çağrılır. LiveData nesnesi mCurrentName içinde bir değer ayarlamadıysa onChanged() çağrılmaz.

LiveData nesnelerini güncelleme

LiveData'nın, depolanan verileri güncellemek için herkese açık bir yöntemi yok. MutableLiveData sınıfı, setValue(T) ve postValue(T) yöntemlerini herkese açık olarak gösterir. Bir LiveData nesnesinde depolanan değeri düzenlemeniz gerekiyorsa bunları kullanmanız gerekir. MutableLiveData genellikle ViewModel içinde kullanılır ve ardından ViewModel, gözlemcilere yalnızca sabit LiveData nesnelerini gösterir.

Gözlemci ilişkisini kurduktan sonra, LiveData nesnesinin değerini aşağıdaki örnekte gösterildiği gibi güncelleyebilirsiniz. Bu güncelleme, 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öntemlerine John Doe değeriyle çağrılıyor. Örnekte bir düğmeye basılması gösterilmektedir, ancak bir ağ isteğine veya veritabanı yükünün tamamlanmasına yanıt vermek de dahil olmak üzere çeşitli nedenlerle mName öğesini güncellemek için setValue() veya postValue() çağrılabilir; her durumda setValue() veya postValue() çağrısı, gözlemcileri tetikler ve kullanıcı arayüzünü günceller.

Room ile LiveData'yı kullanma

Oda kalıcılık kitaplığı, LiveData nesnelerini döndüren gözlemlenebilir sorguları destekler. Gözlemlenebilir sorgular, Veritabanı Erişim Nesnesi (DAO) kapsamında yazılır.

Oda, bir veritabanı güncellendiğinde LiveData nesnesini güncellemek için gerekli tüm kodu oluşturur. Oluşturulan kod, gerektiğinde sorguyu bir 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 açısından yararlıdır. Oda ve DAO'lar hakkında daha fazla bilgiyi Oda kalıcı kitaplığı kılavuzundan edinebilirsiniz.

LiveData ile eş yordamları kullanma

LiveData, Kotlin eş yordamlarını destekler. Daha fazla bilgi için Android Mimari Bileşenleri ile Kotlin eş yordamlarını kullanma bölümüne bakın.

Uygulamanın mimarisindeki LiveData

LiveData, etkinlikler ve parçalar gibi varlıkların yaşam döngüsünü takip ederek yaşam döngüsüne duyarlıdır. Bu yaşam döngüsü sahipleri ile ViewModel nesneleri gibi farklı yaşam süresine sahip diğer nesneler arasında iletişim kurmak için LiveData kullanın. ViewModel öğesinin ana sorumluluğu, kullanıcı arayüzü ile ilgili verileri yükleyip yönetmektir. Bu nedenle LiveData nesnelerini tutmak için mükemmel bir adaydır. ViewModel içinde LiveData nesneleri oluşturun ve bunları kullanıcı arayüzü katmanına durumu göstermek için kullanın.

Etkinlikler ve parçalar, rolleri bekletme durumunu değil verileri görüntülemek olduğundan LiveData örneklerini barındırmamalıdır. Ayrıca, etkinlikleri ve parçaları veri tutmaktan korumak, birim testleri yazmayı kolaylaştırır.

Veri katmanı sınıfınızda LiveData nesneleri çalışmak cazip gelebilir ancak LiveData, eşzamansız veri akışlarını işleyecek şekilde tasarlanmamıştır. Bunu başarmak için LiveData dönüşümlerini ve MediatorLiveData araçlarını kullanabilirsiniz ancak 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 LiveData bulundurmanın ana iş parçacığını nasıl engelleyebileceğine dair bir örnektir:

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 Kotlin Akışları'nı kullanmayı ve ardından ViewModel içinde asLiveData() kullanarak bunları LiveData biçimine dönüştürmeyi düşünün. Bu codelab'de Kotlin Flow ile LiveData kullanma hakkında daha fazla bilgi edinin. Java ile oluşturulan kod tabanları için geri çağırmalarla veya RxJava ile birlikte Yürütücüler'i kullanmayı düşünün.

LiveData'yı genişlet

LiveData, gözlemcinin yaşam döngüsü STARTED veya RESUMED durumundaysa etkin durumda olduğunu kabul eder. Aşağıdaki örnek kod, LiveData sınıfının nasıl genişletileceğini gösterir:

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

  • onActive() yöntemi, LiveData nesnesinde etkin bir gözlemci olduğunda çağrılır. Yani bu yöntemi kullanarak hisse senedi fiyatı güncellemelerini izlemeye başlamanız gerekir.
  • onInactive() yöntemi, LiveData nesnesinde etkin bir gözlemci olmadığında çağrılır. Hiçbir gözlemci dinlemediğinden, StockManager hizmetine bağlı kalmak için bir neden yoktur.
  • setValue(T) yöntemi, LiveData örneğinin değerini günceller ve etkin gözlemcilere değişiklik hakkında bilgi verir.

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

observe() yöntemi, parçanın görünümüyle ilişkilendirilmiş LifecycleOwner öğesini ilk bağımsız değişken olarak aktarır. Böyle yapılması bu gözlemcinin sahiple ilişkilendirilmiş Lifecycle nesnesine bağlı olduğu anlamına gelir. 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üne duyarlı olması, bunları birden fazla etkinlik, parça veya hizmet arasında paylaşabileceğiniz anlamına gelir. Örneği basit tutmak için LiveData sınıfını aşağıdaki gibi tekli 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);
    }
}

Bunu, parçada aşağıdaki gibi 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 yalnızca bir veya daha fazlası görünür ve etkin olduğunda sistem hizmetine bağlanır.

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

Gözlemcilere göndermeden önce LiveData nesnesinde depolanan değerde değişiklikler yapmak 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ı da sunar.

Transformations.map()
LiveData nesnesinde depolanan değere bir işlev uygular ve sonucu aşağı yönde 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 nesnesinde depolanan değere bir işlev uygular ve sarmalama açılıp sonucu aşağı gönderir. switchMap() işlevine iletilen işlev, aşağıdaki örnekte gösterildiği gibi bir LiveData nesnesi döndürmelidir:

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 yaşam döngüsü boyunca bilgi taşımak için dönüştürme yöntemlerini kullanabilirsiniz. Bir gözlemci döndürülen LiveData nesnesini izlemiyorsa dönüşümler hesaplanmaz. Dönüşüm işlemleri geç hesaplandığından, yaşam döngüsüyle ilgili davranış ek açık çağrılar veya bağımlılıklar gerektirmeden dolaylı yoldan aktarılır.

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

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

Kullanıcı arayüzü bileşeninin, getPostalCode() nesnesini her çağırdığında önceki LiveData nesnesine olan kaydını iptal etmesi ve yeni örneğe kaydolması gerekir. Buna ek olarak, 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ıyı tetikler.

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

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

Bu mekanizma, uygulamanın daha düşük seviyelerinin isteğe bağlı olarak geç hesaplanan LiveData nesneleri oluşturmasına olanak tanır. ViewModel nesnesi, LiveData nesnelerine yönelik referansları kolayca elde edip bunların üzerinde dönüştürme kuralları tanımlayabilir.

Yeni dönüşüm oluşturma

Uygulamanızda yararlı olabilecek bir dizi farklı özel dönüşüm vardır, ancak bunlar varsayılan olarak sağlanmaz. Kendi dönüşümünüzü uygulamak için MediatorLiveData sınıfını kullanabilirsiniz. Bu sınıf, diğer LiveData nesnelerini dinler ve bu nesnelerin yayınladığı etkinlikleri işler. MediatorLiveData, durumunu kaynak LiveData nesnesine doğru bir şekilde yayar. Bu kalıp hakkında daha fazla bilgi edinmek için Transformations sınıfının referans belgelerine bakın.

Birden fazla LiveData kaynağını birleştirme

MediatorLiveData, birden fazla LiveData kaynağını birleştirmenize olanak tanıyan bir LiveData alt sınıfıdır. Daha sonra, orijinal LiveData kaynak nesnelerinden herhangi biri her 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üncellenebilen bir LiveData nesnesi varsa aşağıdaki kaynakları MediatorLiveData nesnesine ekleyebilirsiniz:

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

Her iki kaynaktan da güncelleme almak için etkinliğinizin yalnızca MediatorLiveData nesnesini gözlemlemesi gerekir. Ayrıntılı bir örnek için Uygulama Mimarisi Rehberi'nin Ek: 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 başvurun.

Sana Özel

Codelab uygulamaları

Bloglar

Videolar