lifecycleScope — nedir, Lifecycle ile bağlantısı ve Android’de kullanımı

Android’de lifecycleScope nedir?

lifecycleScope, LifecycleOwner arayüzünde (Activity, Fragment, Service) bir uzantı özelliğidir ve bileşenin tam yaşam döngüsüne bağlı, hazır bir CoroutineScope sağlar. LifecycleOwner DESTROYED durumuna ulaştığında, lifecycleScope tüm etkin coroutine’ları otomatik olarak iptal eder.

// In Fragment or Activity
lifecycleScope.launch {
    delay(1000)
    showSnackbar("Merhaba!")
}

viewModelScope’un aksine, lifecycleScope LifecycleOwner her yok edildiğinde iptal edilir — ekran döndürme dahil. Bu, onu yalnızca belirli bir ekran görünürken yaşaması gereken işlemler için ideal hale getirir.

lifecycleScope’un kullanılabildiği yerler

lifecycleScope, LifecycleOwner’ın olduğu her yerde kullanılabilir:

• Activity — AppCompatActivity, LifecycleOwner’ı devralır
• Fragment — Fragment, LifecycleOwner’ı devralır
• LifecycleService — yaşam döngüsü olan bir hizmet
• ProcessLifecycleOwner — tüm uygulamanın yaşam döngüsü
• Özel LifecycleOwner — LifecycleOwner’ı uygulayan herhangi bir nesne

lifecycleScope nasıl çalışır: Lifecycle ve otomatik iptal

lifecycleScope’un otomatik iptal mekanizması, Lifecycle olaylarına abone olmaya dayanır. Lifecycle, CREATED’ın altına DESTROYED’a düştüğünde, scope iptal edilir.

Lifecycle durumları

lifecycleScope’un iç yapısı

lifecycleScope, CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) olarak oluşturulur ve Lifecycle içinde saklanır. Lifecycle DESTROYED durumuna geçtiğinde, scope.cancel() çağrılır. Mekanizma, scope’a ilk erişimde yaşam döngüsü olaylarına abone olan LifecycleEventObserver aracılığıyla uygulanır.

Döndürme sırasında davranış

Ekran döndürüldüğünde, Activity yok edilir (onDestroy) ve yeniden oluşturulur. lifecycleScope, eski Activity ile birlikte iptal edilir ve yeni Activity için yeni bir scope örneği oluşturulur. Bu, döndürmede hayatta kalan viewModelScope’dan temel bir farktır.

lifecycleScope API: launch, launchWhen ve repeatOnLifecycle

lifecycle kütüphanesi, lifecycleScope aracılığıyla coroutine başlatmanın birkaç yolunu sağlar. API’nin kullanımdan kaldırılmış yöntemlerden moderne evrimini inceleyelim.

lifecycleScope.launch — Temel başlatma

En basit yol lifecycleScope.launch { ... }’dir. Coroutine hemen başlar ve DESTROYED’da iptal edilir. Ancak, UI görünür olmasa bile kod çalıştırabilir (örneğin, onStop’tan sonra arka planda). Bu her zaman istenen bir durum değildir.

Kullanımdan kaldırılmış: launchWhenCreated / launchWhenStarted / launchWhenResumed

Bu yöntemler, Lifecycle belirtilen durumun altına düştüğünde coroutine yürütmesini duraklatır ve geri dönüşte devam ettirirdi. Ancak, lifecycle-runtime-ktx 2.6.0’da @Deprecated olarak işaretlendiler çünkü:

• Coroutine’u iptal etmezlerdi — yalnızca duraklatırlardı
• Bellek tüketen askıda coroutine birikimine yol açarlardı
• Hızlı durum geçişlerinde yarış koşulları oluştururlardı

Modern API: repeatOnLifecycle

repeatOnLifecycle, Google tarafından yaşam döngüsüyle senkronize edilmiş coroutine’ları başlatmak için önerilen yöntemdir. Lifecycle belirtilen duruma her ulaştığında coroutine’u iptal eder ve yeniden başlatır.

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.uiState.collect { state ->
            updateUI(state)
        }
    }
}

repeatOnLifecycle’a aktarılan coroutine, Lifecycle STARTED’a ulaştığında başlar ve STARTED’ın altına düştüğünde iptal edilir. STARTED’a geri dönüldüğünde, coroutine baştan yeniden başlar. Bu güvenli ve verimlidir — hiçbir coroutine askıda kalmaz.

flowWithLifecycle — Flow için

Yaşam döngüsü farkındalığıyla Flow’dan veri toplamak için flowWithLifecycle operatörü vardır. Lifecycle durumu değiştiğinde toplamayı otomatik olarak durdurur ve devam ettirir:

viewModel.uiState
    .flowWithLifecycle(lifecycle, Lifecycle.State.STARTED)
    .onEach { state -> updateUI(state) }
    .launchIn(lifecycleScope)

flowWithLifecycle operatörü, UI katmanında bir Flow’a güvenle abone olmanın en kısa yoludur.

lifecycleScope kullanım örnekleri

Kotlin ile bir Android uygulamasında lifecycleScope kullanımının üç gerçek senaryosunu inceleyelim.

Örnek 1: Yalnızca ekran görünürken konum güncellemelerine abone olma

class MapFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                locationProvider.observeLocation().collect { loc ->
                    updateMapMarker(loc)
                }
            }
        }
    }
}

Coroutine, fragment görünür hale geldiğinde (STARTED) başlar ve ekrandan ayrıldığında (STOPPED) iptal edilir. Kullanıcı başka bir uygulamaya geçerse, konum güncellemeleri pil tüketmez.

Örnek 2: Fragment başladığında animasyon başlatma

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.RESUMED) {
        animateFadeIn(titleView)
        delay(200)
        animateSlideUp(contentView)
    }
}

Animasyon yalnızca fragment ön plandayken (RESUMED) çalışır. Kullanıcı animasyon sırasında uygulamayı küçültürse, coroutine iptal edilir ve geri dönüldüğünde animasyon yeniden başlar.

Örnek 3: Görünür ekranda periyodik veri senkronizasyonu

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        while (isActive) {
            syncData()
            delay(30_000L)
        }
    }
}

Veriler her 30 saniyede bir senkronize edilir, ancak yalnızca ekran görünürken. isActive, coroutine’un iptal edilip edilmediğini kontrol ederek ekrandan ayrılırken döngüden güvenli bir çıkış sağlar.

lifecycleScope vs viewModelScope: kullanım senaryoları

Her iki scope da yaşam döngüsüne bağlıdır, ancak farklı yönlerine. Farkı anlamak, doğru Android uygulama mimarisi için kritiktir.

Temel fark

viewModelScope, ekran döndürmede hayatta kalan ViewModel’e bağlıdır. lifecycleScope, döndürmede yok edilen ve yeniden oluşturulan LifecycleOwner’a (Activity/Fragment) bağlıdır. Bu, kullanım senaryolarını belirler.

lifecycleScope ne zaman kullanılır

• Sistem olaylarına abone olma (konum, sensörler, kamera)
• Belirli bir ekrana bağlı animasyonlar ve UI efektleri
• Ekran görünürlüğüne göre parçalı veri yükleme
• Ekrandan ayrılırken durması gereken işlemler

viewModelScope ne zaman kullanılır

• Bir Repository’den veri yükleme
• Döndürmede hayatta kalması gereken iş mantığı
• Veri önbelleğe alma ve işleme
• Sonucu döndürmeden sonra gereken herhangi bir işlem

Birleşik kullanım

Pratikte, her iki scope’un birleşimi yaygındır: viewModelScope verileri yükler ve durumu yönetirken, lifecycleScope yaşam döngüsü farkındalığıyla ViewModel’den Flow’a abone olur. Bu sorumluluk ayrımı, modern Android geliştirmede en iyi uygulama olarak kabul edilir.

lifecycleScope ile çalışırken yaygın hatalar

lifecycleScope kullanırken geliştiricilerin yaptığı en yaygın dört hatayı inceleyelim.

Hata 1: Veri yüklemek için viewModelScope yerine lifecycleScope kullanmak

lifecycleScope.launch içinde veri yükleme başlatırsanız, ekran döndürmede coroutine iptal edilir ve verilerin yeniden yüklenmesi gerekir. Uzun süreli işlemler için viewModelScope kullanın. lifecycleScope yalnızca UI’ya bağlı görevler içindir.

Hata 2: repeatOnLifecycle olmadan Flow toplamak

lifecycleScope.launch içinde doğrudan viewModel.someFlow.collect { ... } çağırmak, ekran görünür olmasa bile veri toplamaya devam eder. Bu, arka planda UI güncellemelerine ve gereksiz yüke neden olabilir. Her zaman repeatOnLifecycle veya flowWithLifecycle kullanın.

Hata 3: Ekrandan ayrılırken iptali unutmak

lifecycleScope DESTROYED’da iptal edilse de, ani iptalde askı noktasından sonraki kod çalışmayabilir. NonCancellable kullanmıyorsanız, bir suspend çağrısından sonraki kod yürütmesine güvenmeyin.

Hata 4: repeatOnLifecycle yerine kullanımdan kaldırılmış launchWhenStarted kullanmak

launchWhenStarted ve benzerleri coroutine’u iptal etmez, yalnızca duraklatır. Ekran ön plan ve arka plan arasında birkaç kez geçiş yaparsa, coroutine ertelenmiş çağrıları biriktirir. repeatOnLifecycle’a geçin — Lifecycle ile senkronize olmanın tek doğru yolu budur.