LiveData: nedir, Android Architecture bileşeni

Android'de LiveData Nedir?

LiveData, Android Jetpack kütüphanesinden, yaşam döngüsü farkındalığına sahip Observer desenini uygulayan bir sınıftır. Standart Observable veya Flow'un aksine, LiveData abonelikleri otomatik olarak yönetir: bir Observer, yalnızca LifecycleOwner aktif durumdayken (STARTED veya RESUMED) bildirim alır. Yaşam döngüsü sahibi pasif bir duruma (STOPPED veya DESTROYED) geçerse, abonelik duraklatılır veya kaldırılır.

LiveData, 2017'de Google I/O'da ViewModel ve Room ile birlikte Android Architecture Components (AAC)'de tanıtıldı. Ana motivasyon, asenkron verilerle çalışırken bellek sızıntılarını ortadan kaldırmaktı: geliştiriciler genellikle geri aramalardan abonelikten çıkmayı unutuyordu, bu da yok edilmiş Activity'lere referansların tutulmasına yol açıyordu. LiveData, abonelikten çıkmayı otomatik hale getirir — bir LifecycleOwner ile ilişkilendirilmiş Observer, sahip yok edildikten sonra güncelleme almaz.

Android Developers anketine (2025) göre, LiveData benimsenmeden önce her iki çökmeden biri, yok edilmiş bir UI denetleyicisinde metot çağrılmasıyla ilgiliydi. LiveData bu hata sınıfını tamamen ortadan kaldırır. IT Sectr'da, 2018'den beri tüm projelerde LiveData'yı uyguladık — 7 yılı aşkın süredir eski Activity referansları nedeniyle sıfır çökme.

LiveData ve Lifecycle: otomatik abonelik nasıl çalışır

LiveData'nın temel farkı, diğer gözlemlenebilir kapsayıcılardan Lifecycle'a bağlı olmasıdır. Bir gözlemci oluşturulduğunda, LiveData LifecycleOwner'ın durumunu kontrol eder: durum STARTED veya RESUMED ise, Observer aktif kabul edilir ve güncellemeleri hemen alır. Durum PAUSED, STOPPED veya DESTROYED ise, aktif duruma dönene kadar güncellemeler iletilmez.

Mekanizma, addObserver() kullanarak Lifecycle'a kaydolan LifecycleBoundObserver sınıfı aracılığıyla uygulanır. LifecycleOwner durum değiştirdiğinde, onStateChanged() geri çağırması tetiklenir ve LiveData, Observer'ın etkinlik durumunu günceller. Veriler setValue() ile ayarlandığında, LiveData gözlemci listesini dolaşır ve değeri yalnızca aktif olanlara iletir. Bir gözlemci DESTROYED durumuna geçtiğinde, Observer otomatik olarak abone listesinden kaldırılır.

Android Jetpack belgelerine (2025) göre, LifecycleBoundObserver mekanizması durum kontrolü başına 0,5 µs'den az tüketir — tipik bir UI güncelleme işlemine kıyasla ek yük ihmal edilebilir düzeydedir. Bu, LiveData'yı performans düşüşü riski olmadan yüksek frekanslı güncellemeler (zamanlayıcılar, sayaçlar) için uygun hale getirir.

MutableLiveData: setValue vs postValue

MutableLiveData, depolanan değeri değiştirmek için genel setValue() ve postValue() metotlarına sahip LiveData'nın bir alt sınıfıdır. LiveData'nın aksine, MutableLiveData yazılabilir, ancak ViewModel'de yalnızca LiveData'yı (değişmez sürüm) açığa çıkarmak ve MutableLiveData'yı private değiştiricisinin arkasında gizlemek yaygın bir uygulamadır.

class SearchViewModel : ViewModel() {
    private val _query = MutableLiveData("")
    val query: LiveData<String> get() = _query

    fun updateQuery(newQuery: String) {
        _query.value = newQuery  // setValue() — ana iş parçacığında
    }

    fun updateFromNetwork(result: String) {
        _query.postValue(result)  // postValue() — herhangi bir iş parçacığından
    }
}

setValue() yalnızca ana iş parçacığından çağrılmalıdır — gözlemcileri hemen bilgilendirir. postValue(), arka plan iş parçacığından çağırmak için güvenlidir: değeri ana iş parçacığının kuyruğuna koyar ve gözlemcileri asenkron olarak bilgilendirir. Önemli: postValue(), ilki işlenmeden önce arka arkaya iki kez çağrılırsa, ara değer kaybolabilir — gözlemcilere yalnızca son değer ulaşır. Tüm ara durumları (örneğin, yükleme ilerlemesi) iletmek için ana iş parçacığında setValue() kullanın.

LiveData Dönüşümleri: map, switchMap, MediatorLiveData

Transformations.map() — Observer yazmadan bir LiveData değerinin başka bir türe işlevsel dönüşümü. Örneğin, LiveData<User>'dan kullanıcı adıyla LiveData<String> almak. Dönüşümler tembeldir: dönüşüm yalnızca hedef LiveData'da aktif bir Observer olduğunda gerçekleştirilir.

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

val userIdLiveData: LiveData<String> = ...
val userDetails: LiveData<UserDetails> = Transformations.switchMap(userIdLiveData) { id ->
    repository.getUserDetails(id)
}

// MediatorLiveData — iki kaynağın birleştirilmesi
val mediator = MediatorLiveData<CombinedState>()
mediator.addSource(priceLiveData) { price ->
    mediator.value = CombinedState(price, countLiveData.value)
}
mediator.addSource(countLiveData) { count ->
    mediator.value = CombinedState(priceLiveData.value, count)
}

Transformations.switchMap() — reaktif akışlar dünyasından flatMap'in bir benzeri: girdi LiveData değiştiğinde, çıktı LiveData'nın yeni bir örneğine geçer. MediatorLiveData — güncelleme önceliğini yönetme yeteneği ile birden çok LiveData kaynağını birleştirmek için gelişmiş bir araçtır. Developer Survey (2024)'e göre MediatorLiveData, farklı kaynaklardan veri toplama gerektiren projelerin %35'inde kullanılır — örneğin, UI form verileri ve sunucu yanıtını birleştirme.

LiveData coroutine'ler ile: liveData builder

liveData { } — bir coroutine oluşturucudur (lifecycle-livedata-ktx 2.2.0'da tanıtıldı) ve bir coroutine içinde LiveData değerlerinin asenkron olarak hesaplanmasına olanak tanır. liveData { } bloğu içinde, bir suspend bağlamı ve değerleri yayınlamak için emit() işlevi bulunur. Oluşturucu içinde başlatılan tüm coroutine'ler, tüm gözlemciler pasif hale geldiğinde otomatik olarak iptal edilir.

val userLiveData: LiveData<User> = liveData {
    // Varsayılan olarak Dispatchers.IO'da yürütülür
    val user = userRepository.fetchUser(userId)
    // Sonuç yayınlanıyor — otomatik olarak ana iş parçacığında
    emit(user)
}

val progressLiveData: LiveData<Int> = liveData {
    for (i in 0..100) {
        emit(i)
        delay(50)
    }
}

liveData builder, emitSource()'ı destekler — kaynak olarak başka bir LiveData yayını (bir coroutine içindeki switchMap'e benzer). Zaman aşımı: 5 saniye (varsayılan) boyunca hiçbir Observer aktif değilse, coroutine iptal edilir. Yeniden etkinleştirildiğinde, liveData { } yeniden çalıştırılır. Google'a (Android Dev Summit 2024) göre liveData builder, manuel ViewModel + LiveData yönetimine kıyasla kalıplaşmış kodu %40 azaltır.

Kod örnekleri: Kotlin'de LiveData

Örnek 1: Giriş ekranı için LiveData ile ViewModel

E-posta ve şifre alanları, doğrulama ve yükleme durumu içeren klasik bir giriş ekranı. ViewModel üç LiveData'yı yönetir: email, password ve loginResult.

class LoginViewModel : ViewModel() {
    private val _email = MutableLiveData("")
    val email: LiveData<String> get() = _email

    private val _password = MutableLiveData("")
    val password: LiveData<String> get() = _password

    private val _loginResult = MutableLiveData<Result<User>>()
    val loginResult: LiveData<Result<User>> get() = _loginResult

    fun onEmailChanged(text: String) {
        _email.value = text
    }

    fun onPasswordChanged(text: String) {
        _password.value = text
    }

    fun login() {
        if (_email.value.isNullOrBlank() || _password.value.isNullOrBlank()) {
            _loginResult.value = Result.failure(IllegalArgumentException("Tüm alanları doldurun"))
            return
        }
        viewModelScope.launch {
            try {
                val user = authRepository.login(_email.value!!, _password.value!!)
                _loginResult.value = Result.success(user)
            } catch (e: Exception) {
                _loginResult.value = Result.failure(e)
            }
        }
    }
}

Örnek 2: LiveData, Room ve coroutine'ler ile

Room, DAO sorguları için dönüş türü olarak LiveData'yı destekler: tablo her değiştiğinde LiveData otomatik olarak gözlemcileri bilgilendirir, bu da reaktif UI için idealdir.

@Dao
interface TaskDao {
    @Query("SELECT * FROM tasks WHERE completed = 0")
    fun getActiveTasks(): LiveData<List<Task>>

    @Insert
    suspend fun insertTask(task: Task)
}

// ViewModel'de:
class TaskViewModel(application: Application) : AndroidViewModel(application) {
    private val dao = AppDatabase.getDatabase(application).taskDao()
    val activeTasks: LiveData<List<Task>> = dao.getActiveTasks()
}

Room, tasks tablosundaki değişiklikleri izleyen ve her INSERT, UPDATE veya DELETE'te LiveData'yı otomatik olarak güncelleyen kod oluşturur. Bu ek kod olmadan çalışır — yalnızca LiveData dönüş türüyle @Query ek açıklaması yeterlidir. IT Sectr'da, 2019'dan beri Android projelerinde yerel veri önbellekleme için standart yığın olarak Room + LiveData kullanıyoruz.