App Lifecycle: nima, iOS va Android'da ilova holatlari

App Lifecycle nima?

App Lifecycle — mobil ilovaning barcha mumkin bo'lgan holatlari va ular orasidagi o'tishlarni tavsiflovchi chekli avtomat. Har bir holat ilova kodni bajarishi, UI ko'rsatishi va resurslarni iste'mol qilishi mumkinligini aniqlaydi. iOS va Android o'xshash, ammo bir xil bo'lmagan modelga ega — farqlar OT arxitekturasi bilan bog'liq: iOS qattiq xotira nazoratidan (suspended holati) foydalanadi, Android — onSaveInstanceState orqali moslashuvchan jarayon boshqaruvi.

iOS'da lifecycle foreground/background bilan qattiq bog'langan: ilova yo aktiv yoki to'xtatilgan. Android'da lifecycle ko'proq granular — Activity/Window 6+ holatdan o'tadi va jarayonning o'zi ProcessLifecycleOwner orqali qo'shimcha lifecycle-ga ega. Zamonaviy ilovalar (2024 yildan) tobora ko'proq lifecycle-ga asoslangan arxitektura naqshlaridan foydalanadi: SwiftUI Lifecycle (iOS 16+) .scenePhase environment orqali, Compose Lifecycle LifecycleEventObserver orqali. Bu naqshlar kontekst almashinuvini avtomatik boshqaradi va xotira oqishining oldini oladi. Google ma'lumotlariga ko'ra, Android'da lifecycle-ni to'g'ri qayta ishlash fon ishi vaqtida xotira iste'molini 30–40% kamaytiradi.

iOS hayot sikli: AppDelegate va SceneDelegate

iOS'da ilova lifecycle-i UIApplicationDelegate (AppDelegate) klassi orqali boshqariladi. Asosiy metodlar: application(_:didFinishLaunchingWithOptions:) — birinchi ishga tushirishda inizializatsiya; applicationDidBecomeActive — ilova ko'rinadi va o'zaro aloqaga tayyor; applicationWillResignActive — nofaol holatga o'tish (kiruvchi qo'ng'iroq, pardani yopish); applicationDidEnterBackground — ilova yashirin, ma'lumotlarni saqlash uchun ~5 soniya bor; applicationWillEnterForeground — fondan qaytish; applicationWillTerminate — tugatish (faqat suspended bo'lmagan eski ilovalar uchun chaqiriladi).

iOS 13 dan boshlab, Apple iPad va macOS Catalyst'da ko'p oynali ilovalarni qo'llab-quvvatlash uchun SceneDelegate (UISceneDelegate) ni joriy qildi. SceneDelegate har bir alohida sahnaning (oynaning) lifecycle-ni boshqaradi: scene(_:willConnectTo:options:) — sahna yaratish; sceneDidBecomeActive — sahna aktiv; sceneWillResignActive — sahna fokusni yo'qotadi; sceneDidEnterBackground — sahna yashirin. AppDelegate global hodisalar (ma'lumot yuklash, push bildirishnomalar) uchun javobgar, SceneDelegate esa — har bir oynaning UI holati uchun. SwiftUI'da lifecycle @Environment(\.scenePhase) muhit qiymati orqali boshqariladi: .active, .inactive, .background — bu SwiftUI va UIKit ilovalari uchun yagona API ni ta'minlaydi.

Android hayot sikli: Application va ProcessLifecycleOwner

Android'da lifecycle Application klassi bilan boshlanadi — har qanday Activity'dan oldin yaratiladigan singleton. Application.onCreate() metodi — birinchi kirish nuqtasi, global inizializatsiya uchun ishlatiladi (Analytics, DI, Crash Reporting). Shundan so'ng Activity ketma-ketlik bilan ishga tushadi: onCreate() → onStart() → onResume(). Kichiklashtirishda: onPause() → onStop() → onSaveInstanceState(). Yo'q qilishda: onDestroy(). Qaytishda: onRestart() → onStart() → onResume().

ProcessLifecycleOwner (AndroidX Lifecycle 2.2+) alohida Activity emas, balki butun jarayonning lifecycle-ni kuzatadi. Ikki holatni ta'minlaydi: ON_RESUME (ilova foreground'da) va ON_STOP (ilova yashirin). ProcessLifecycleOwner "ilova qachon fonga ketdi" muammosini jarayon darajasida hal qiladi — bu SDK'lar, kutubxonalar va modulli ilovalar uchun juda muhim. Jetpack Compose'da lifecycle LifecycleEventObserver va collectAsStateWithLifecycle orqali boshqariladi, u fon rejimida ma'lumot yig'ishni avtomatik to'xtatadi. Android 14 (API 34) foreground service lifecycle haqida bildirishnomani Service.onTimeout orqali qo'shdi — xizmat 6 soat ichida tugashi kerak, aks holda tizim uni majburiy to'xtatadi.

iOS va Android lifecycle taqqoslashi

Asosiy farq: iOS fonga o'tgandan 5-10 soniya o'tib ilovani majburiy Suspended holatiga o'tkazadi (kod bajarilmaydi). Android uzoqroq vaqt fon ishiga (xizmatlar, WorkManager) ruxsat beradi, lekin Doze Mode (Android 6+) va fon cheklovlari (Android 12+) bilan. Android'dagi ProcessLifecycleOwner — iOS'dagi UIApplicationDidEnterBackgroundNotification ning analogi, farqi shundaki, u har qanday fonga o'tishda ishga tushadi, faqat fokus yo'qotilishidan keyin emas.

Kod namunalari

iOS: Lifecycle metodlari bilan AppDelegate

Hayot siklining barcha holatlarini qayta ishlaydigan asosiy AppDelegate implementatsiyasi. Fonga o'tishda ma'lumotlarni saqlash va qaytishda UI ni yangilash.

import UIKit
@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        Analytics.shared.initialize()
        return true
    }
    func applicationDidBecomeActive(_ application: UIApplication) { NotificationCenter.default.post(name: .appDidBecomeActive, object: nil) }
    func applicationWillResignActive(_ application: UIApplication) { NotificationCenter.default.post(name: .appWillResignActive, object: nil) }
    func applicationDidEnterBackground(_ application: UIApplication) {
        CoreDataManager.shared.saveContext()
        UserDefaults.standard.synchronize()
    }
    func applicationWillEnterForeground(_ application: UIApplication) { NetworkManager.shared.refreshSession() }
}

AppDelegate — lifecycle ning markaziy nuqtasi. applicationDidEnterBackground — muhim metod: iOS ma'lumotlarni saqlash uchun ~5 soniya beradi. applicationDidBecomeActive — UI ni yangilang, animatsiyalarni qayta ishga tushiring. SceneDelegate (iOS 13+) uchun lifecycle mantiqiy sahnalarga bo'linadi: sceneDidBecomeActive / sceneDidEnterBackground alohida oynalarni boshqaradi.

iOS: SceneDelegate (iOS 13+)

iPad uchun ko'p oynali ilovalar uchun SceneDelegate. Har bir sahna boshqa oynalardan mustaqil o'z lifecycle-iga ega.

import UIKit
class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        guard let windowScene = (scene as? UIWindowScene) else { return }
        window = UIWindow(windowScene: windowScene)
        window?.rootViewController = ViewController()
        window?.makeKeyAndVisible()
    }
    func sceneDidBecomeActive(_ scene: UIScene) { PlayerManager.shared.resume() }
    func sceneDidEnterBackground(_ scene: UIScene) {
        PlayerManager.shared.pause()
        CoreDataManager.shared.saveContext()
    }
    func sceneDidDisconnect(_ scene: UIScene) { PlayerManager.shared.cleanup() }
}

SceneDelegate alohida sahna lifecycle-ni boshqaradi. sceneDidBecomeActive / sceneDidEnterBackground — ma'lum bir oyna uchun AppDelegate metodlarining analogi. sceneDidDisconnect sahna yopilganda chaqiriladi (foydalanuvchi iPad'da oynani yopdi). iOS 12 va eskilari bilan moslikni saqlash uchun AppDelegate SceneDelegate mantiqini takrorlashi kerak. iOS 17+ da scenePhase asosida vazifalarni avtomatik to'xtatish/davom ettirish uchun @Observable dan foydalanishingiz mumkin.

Android: ProcessLifecycleOwner bilan Application

ProcessLifecycleOwner ilova foreground/background da ekanligini jarayon darajasida kuzatadi. Bu global lifecycle boshqaruvi uchun optimal usul.

import android.app.Application
import androidx.lifecycle.ProcessLifecycleOwner
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent
class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver())
    }
}
class AppLifecycleObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onEnterForeground() { Analytics.shared.onForeground(); NetworkMonitor.shared.start() }
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onEnterBackground() { Analytics.shared.onBackground(); NetworkMonitor.shared.stop() }
}

ProcessLifecycleOwner — ilova darajasida fonga o'tishni kuzatishning yagona to'g'ri usuli. ON_START ilova ko'ringanda (foreground), ON_STOP — to'liq yashiringanda (background) ishga tushadi. Activity lifecycle dan farqli o'laroq, ProcessLifecycleOwner ma'lum bir ekranga bog'liq emas. Jetpack Compose uchun qo'lda kuzatish o'rniga LifecycleResumeEffect yoki collectAsStateWithLifecycle dan foydalaning.

Android: ViewModel bilan Activity Lifecycle

ViewModel + Lifecycle — lifecycle bilan ishlash uchun to'g'ri Android arxitekturasi. ViewModel onDestroy da avtomatik tozalanadi, xotira oqishining oldini oladi.

import androidx.lifecycle.ViewModel
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
class TimerViewModel : ViewModel() {
    private val _time = MutableLiveData<Long>()
    val time: LiveData<Long> = _time
    private var startTime = System.currentTimeMillis()
    init { updateTime() }
    private fun updateTime() { _time.value = System.currentTimeMillis() - startTime }
    override fun onCleared() { super.onCleared(); Logger.d("ViewModel cleared — resurslarni bo'shatish") }
}
// Activity da
class TimerActivity : AppCompatActivity() {
    private val viewModel: TimerViewModel by viewModels()
    override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState); Logger.d("Activity created") }
    override fun onResume() { super.onResume(); viewModel.time.observe(this) { Logger.d("Time: $it") } }
    override fun onPause() { super.onPause(); Logger.d("Activity paused — animatsiyalarni to'xtatish") }
    override fun onDestroy() { super.onDestroy(); Logger.d("Activity destroyed — tozalash") }
}

ViewModel ekran aylanishidan omon qoladi va faqat finish() Activity da yo'q qilinadi. onCleared() — resurslarni bo'shatish, oqimlardan chiqish joyi. LiveData onPause da kuzatishni avtomatik to'xtatadi va onResume da davom ettiradi — bu fon ishi vaqtida xotira oqishi va nosozliklardan himoya qiladi. Compose'da xuddi shu maqsadda collectAsStateWithLifecycle() dan foydalaning.