lifecycleScope — bu nima, Lifecycle bilan bog'lanish va Android-da ishlash

Android-da lifecycleScope nima?

lifecycleScope — LifecycleOwner (Activity, Fragment, Service) interfeysidagi kengaytma xususiyati bo'lib, komponentning to'liq hayot aylanishiga bog'langan tayyor CoroutineScope ni ta'minlaydi. LifecycleOwner DESTROYED holatiga yetganda, lifecycleScope barcha faol korutinlarni avtomatik bekor qiladi.

// Fragment yoki Activity da
lifecycleScope.launch {
    delay(1000)
    showSnackbar("Salom!")
}

viewModelScope dan farqli o'laroq, lifecycleScope har bir LifecycleOwner yo'q qilinganda — ekran rotatsiyasini ham o'z ichiga olgan holda — bekor qilinadi. Bu uni faqat ma'lum bir ekran ko'rinadigan bo'lganda yashashi kerak bo'lgan operatsiyalar uchun ideal qiladi.

lifecycleScope qayerda mavjud

lifecycleScope LifecycleOwner mavjud bo'lgan har qanday joyda mavjud:

• Activity — AppCompatActivity LifecycleOwner dan meros oladi
• Fragment — Fragment LifecycleOwner dan meros oladi
• LifecycleService — hayot aylanishiga ega xizmat
• ProcessLifecycleOwner — butun ilovaning hayot aylanishi
• Maxsus LifecycleOwner — LifecycleOwner ni amalga oshiradigan har qanday ob'ektlar

lifecycleScope qanday ishlaydi: Lifecycle va avtomatik bekor qilish

Avtomatik bekor qilish mexanizmi Lifecycle hodisalariga obuna bo'lishga asoslangan. Lifecycle CREATED dan DESTROYED ga tushganda, scope bekor qilinadi.

Lifecycle holatlari

lifecycleScope ning ichki tuzilishi

lifecycleScope CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) sifatida yaratiladi va Lifecycle ichida saqlanadi. Lifecycle DESTROYED holatiga o'tganda scope.cancel() chaqiriladi. Mexanizm scope ga birinchi murojaatda hayot aylanishi hodisalariga obuna bo'ladigan LifecycleEventObserver orqali amalga oshiriladi.

Rotatsiya paytidagi harakat

Ekran aylantirilganda, Activity yo'q qilinadi (onDestroy) va qayta yaratiladi. lifecycleScope eski Activity bilan birga bekor qilinadi va yangi Activity uchun yangi scope namunasi yaratiladi. Bu rotatsiyada saqlanib qoladigan viewModelScope dan printsipial farqdir.

lifecycleScope API: launch, launchWhen va repeatOnLifecycle

Lifecycle kutubxonasi lifecycleScope orqali korutinlarni ishga tushirishning bir necha usullarini ta'minlaydi. Eskirgan metodlardan zamonaviy metodlargacha API evolyutsiyasini ko'rib chiqaylik.

lifecycleScope.launch — asosiy ishga tushirish

Eng oddiy usul — lifecycleScope.launch { ... }. Korutin darhol ishga tushadi va DESTROYED da bekor qilinadi. Biroq, UI ko'rinmasa ham kodni bajarishi mumkin (masalan, onStop dan keyin fonda). Bu har doim ham istalmagan.

Eskirgan: launchWhenCreated / launchWhenStarted / launchWhenResumed

Bu metodlar Lifecycle belgilangan holatdan pastga tushganda korutin bajarilishini to'xtatar va qaytganda davom ettirardi. Biroq ular lifecycle-runtime-ktx 2.6.0 da @Deprecated deb belgilandi, chunki:

• Korutinni bekor qilmasdi — faqat to'xtatar edi
• Xotirani iste'mol qiladigan osilgan korutinlarning to'planishiga olib kelar edi
• Tez holat almashishda race condition yaratar edi

Zamonaviy API: repeatOnLifecycle

repeatOnLifecycle — Google tomonidan tavsiya etilgan, hayot aylanishi bilan sinxronlashtirilgan korutinlarni ishga tushirish usulidir. Lifecycle belgilangan holatga yetganda korutinni bekor qiladi va qayta ishga tushiradi.

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

repeatOnLifecycle ga uzatilgan korutin Lifecycle STARTED ga yetganda ishga tushadi va STARTED dan pastga tushganda bekor qilinadi. STARTED ga qaytganda korutin qaytadan boshlanadi. Bu xavfsiz va samarali — hech bir korutin pauzada osilib qolmaydi.

flowWithLifecycle — Flow uchun

Flow dan hayot aylanishini hisobga olgan holda ma'lumot yig'ish uchun flowWithLifecycle operatori mavjud. Lifecycle holati o'zgarganda yig'ishni avtomatik to'xtatadi va davom ettiradi:

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

flowWithLifecycle operatori — UI qatlamida Flow ga xavfsiz obuna bo'lishning eng qisqa usulidir.

lifecycleScope dan foydalanish misollari

Kotlin da Android ilovasida lifecycleScope dan foydalanishning uchta real stsenariysini ko'rib chiqaylik.

Misol 1: Faqat ekran ko'rinadigan bo'lganda joylashuv yangilanishlariga obuna bo'lish

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

Korutin fragment ko'rinadigan bo'lganda (STARTED) boshlanadi va ekranni tark etganda (STOPPED) bekor qilinadi. Agar foydalanuvchi boshqa ilovaga o'tsa, joylashuv yangilanishlari batareyani sarf qilmaydi.

Misol 2: Fragment boshlanganda animatsiyani ishga tushirish

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

Animatsiya faqat fragment oldingi planda bo'lganda (RESUMED) ishga tushadi. Agar foydalanuvchi animatsiya paytida ilovani yig'ishtirsa, korutin bekor qilinadi va qaytganda animatsiya qaytadan boshlanadi.

Misol 3: Ko'rinadigan ekranda davriy ma'lumot sinxronizatsiyasi

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

Ma'lumotlar har 30 soniyada sinxronlashtiriladi, lekin faqat ekran ko'rinadigan bo'lganda. isActive korutin bekor qilinmaganligini tekshiradi, bu ekranni tark etishda sikl'dan xavfsiz chiqishni ta'minlaydi.

lifecycleScope vs viewModelScope: qo'llanish stsenariylari

Ikkala scope ham hayot aylanishiga bog'langan, lekin uning turli jihatlariga. Farqni tushunish Android ilovalarining to'g'ri arxitekturasi uchun muhim ahamiyatga ega.

Asosiy farq

viewModelScope ekran rotatsiyasidan omon qoladigan ViewModel ga bog'langan. lifecycleScope rotatsiyada yo'q qilinadigan va qayta yaratiladigan LifecycleOwner (Activity/Fragment) ga bog'langan. Bu ularning qo'llanish stsenariylarini belgilaydi.

Qachon lifecycleScope dan foydalanish kerak

• Tizim hodisalariga obuna bo'lish (joylashuv, sensorlar, kamera)
• Muayyan ekranga bog'liq animatsiyalar va UI effektlari
• Ekran ko'rinishini hisobga olgan holda ma'lumotni qismlab yuklash
• Ekranni tark etganda to'xtatilishi kerak bo'lgan operatsiyalar

Qachon viewModelScope dan foydalanish kerak

• Repozitordan ma'lumot yuklash
• Rotatsiyadan omon qolishi kerak bo'lgan biznes mantig'i
• Ma'lumotni keshlash va qayta ishlash
• Natijasi rotatsiyadan keyin kerak bo'ladigan har qanday operatsiyalar

Birgalikda foydalanish

Amalda ikkala scope ning kombinatsiyasi tez-tez uchraydi: viewModelScope ma'lumot yuklaydi va holatni boshqaradi, lifecycleScope ViewModel dan Flow ga ekranning hayot aylanishini hisobga olgan holda obuna bo'ladi. Bu mas'uliyat taqsimoti zamonaviy Android rivojlanishida best practice hisoblanadi.

lifecycleScope bilan ishlashda tipik xatolar

Dasturchilar lifecycleScope dan foydalanishda yo'l qo'yadigan to'rtta eng keng tarqalgan xatoni ko'rib chiqaylik.

Xato 1: Ma'lumot yuklash uchun viewModelScope o'rniga lifecycleScope dan foydalanish

Ma'lumot yuklashni lifecycleScope.launch da boshlasangiz, ekran rotatsiyasida korutin bekor qilinadi va ma'lumotni qayta yuklash kerak bo'ladi. Uzoq muddatli operatsiyalar uchun viewModelScope dan foydalaning. lifecycleScope — faqat UI bilan bog'liq vazifalar uchun.

Xato 2: repeatOnLifecycle siz Flow yig'ish

lifecycleScope.launch ichida to'g'ridan-to'g'ri viewModel.someFlow.collect { ... } chaqiruvi ekran ko'rinmasa ham ma'lumot yig'ishni davom ettiradi. Bu fonda UI yangilanishlari va keraksiz yukga olib kelishi mumkin. Har doim repeatOnLifecycle yoki flowWithLifecycle dan foydalaning.

Xato 3: Ekranni tark etishda bekor qilishni unutish

lifecycleScope DESTROYED da bekor qilinsa ham, to'xtatish nuqtasidan (suspend) keyingi kod to'satdan bekor qilishda bajarilmasligi mumkin. NonCancellable dan foydalanmasangiz, suspend chaqiruvidan keyingi kod bajarilishiga ishonmang.

Xato 4: repeatOnLifecycle o'rniga eskirgan launchWhenStarted dan foydalanish

launchWhenStarted va uning analoglari korutinni bekor qilmaydi, faqat to'xtatadi. Ekran bir necha marta oldingi va fon plan o'rtasida almashsa, korutin kechiktirilgan chaqiruvlarni to'playdi. repeatOnLifecycle ga o'ting — bu Lifecycle bilan sinxronizatsiyaning yagona to'g'ri usulidir.