Activity Lifecycle: nima bu, Android'da onCreate onStart onResume

Activity Lifecycle nima

Activity Lifecycle (Activity hayot sikl) — bu Android-ilovasining har bir ekrani yaratilishdan to'liq yo'q qilinishgacha o'tadigan holatlar mashinasidir. Android tizimi bu jarayonni foydalanuvchi harakatlariga qarab boshqaradi: ilovani ochish, kichiklashtirish, ekranni aylantirish, kiruvchi qo'ng'iroqqa javob berish, ilovalar o'rtasida almashish va ishni tugatish.

Hayot siklini tushunish har bir Android-ishlab chiquvchisi uchun zarur, chunki tizim xotira yetishmasa istalgan vaqtda Activity ni yo'q qilishi mumkin — va ilova o'z holatini to'g'ri tiklashga majbur. Google Android Vitals (2025) ma'lumotlariga ko'ra, onSaveInstanceState() da holatni saqlashni qayta ishlamaydigan ilovalar Activity qayta yaratilganda 42% ko'proq crash ko'rsatadi.

Hayot sikl oltita asosiy qayta chaqiruv metodlarini o'z ichiga oladi: onCreate(), onStart(), onResume(), onPause(), onStop(), onDestroy(). Qo'shimcha ravishda onRestart() metodi mavjud bo'lib, u Activity to'xtatilgan holatdan qaytganda onStart() dan oldin chaqiriladi. Har bir metod qat'iy belgilangan maqsad va bajarilish vaqtiga ega — tizim ularni ketma-ket chaqiradi va ishlab chiquvchi o'z mantig'ini bajarish uchun ulardan istalganini qayta yozishi mumkin.

Tsiklni uchta asosiy bosqichga bo'lish mumkin: butun hayot davri (onCreate → onDestroy), ko'rinadigan hayot davri (onStart → onStop) va oldingi plandagi hayot davri (onResume → onPause). Ushbu uch darajani tushunish ishga tushirish va resurslarni bo'shatish kodini to'g'ri taqsimlashga yordam beradi.

Activity hayot sikl metodlari

Har bir hayot sikl metodi qat'iy belgilangan vazifani bajaradi. Tizim ularni sobit tartibda chaqiradi va ishlab chiquvchi faqat muayyan mantiq uchun zarur bo'lgan metodlarni qayta yozishi kerak. Hayot sikl metodlarini to'g'ridan-to'g'ri chaqirish tavsiya etilmaydi — bu bilan Android Runtime shug'ullanadi.

Chaqiruvlarning umumiy sxemasi

Ilovani ishga tushirishdagi odatiy ketma-ketlik: onCreate → onStart → onResume. «Orqaga» tugmasini bosganda: onPause → onStop → onDestroy. Kichiklashtirganda: onPause → onStop, so'ng qaytganda: onRestart → onStart → onResume.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    override fun onStart() {
        super.onStart()
    }

    override fun onResume() {
        super.onResume()
    }

    override fun onPause() {
        super.onPause()
    }

    override fun onStop() {
        super.onStop()
    }

    override fun onDestroy() {
        super.onDestroy()
    }

    override fun onRestart() {
        super.onRestart()
    }
}

Har bir qayta yozilgan metod super versiyasini chaqirishi shart — busiz tizim holatlar o'rtasidagi o'tishni to'g'ri yakunlay olmaydi. Bu qoida Android Developers hujjatlarida mustahkamlangan va Android Studio lint qoidalari bilan tekshiriladi.

Hayot siklning uch darajasi

Birinchi daraja — butun hayot davri (entire lifetime): onCreate va onDestroy o'rtasidagi interval. Bu yerda bir martalik ishga tushirish va global resurslarni yakuniy bo'shatish amalga oshiriladi. Ikkinchi daraja — ko'rinadigan hayot davri (visible lifetime): onStart va onStop o'rtasida. Activity ekranda ko'rinadi, lekin boshqa oyna bilan qisman yopilgan bo'lishi mumkin. Uchinchi daraja — oldingi plandagi hayot davri (foreground lifetime): onResume va onPause o'rtasida. Activity vazifalar stekining tepasida joylashgan va foydalanuvchi bilan o'zaro aloqada.

onCreate — Activity yaratish

onCreate() — Activity hayot siklning birinchi va yagona majburiy metodi. U tizim tomonidan Activity namunasi yaratilganda bir marta chaqiriladi. Bu metod savedInstanceState: Bundle? parametrini qabul qiladi, unda agar Activity yo'q qilingandan keyin qayta yaratilsa — masalan, ekran aylantirilganda — avval saqlangan holat mavjud bo'ladi.

onCreate ichida quyidagi vazifalar bajariladi: layout resursini uzatish bilan setContentView() orqali foydalanuvchi interfeysini ishga tushirish, findViewById() orqali View elementlarini bog'lash, RecyclerView va ViewPager uchun adapterlarni sozlash, savedInstanceState dan holatni tiklash, ViewModel va LiveData ni ishga tushirish, bosish va imo-ishora tinglovchilarini sozlash. Metod imkon qadar tez tugashi kerak — bu erda uzoq operatsiyalar birinchi kadrni chizishni bloklaydi, bu esa ilovani ishga tushirish vaqtini oshiradi.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_profile)

    val userNameText: TextView = findViewById(R.id.user_name)
    val loadButton: Button = findViewById(R.id.load_button)

    if (savedInstanceState != null) {
        userNameText.text = savedInstanceState.getString("user_name")
    }

    loadButton.setOnClickListener {
        loadUserProfile()
    }
}

Agar Activity birinchi marta yaratilayotgan bo'lsa, savedInstanceState null ga teng. Ekran aylantirilgandan keyin qayta yaratilganda, Bundle onSaveInstanceState() da saqlangan ma'lumotlarni o'z ichiga oladi. Null ni tekshirish — foydalanuvchi kiritgan ma'lumotlarni yo'qotmasdan UI ni to'g'ri tiklash uchun standart amaliyotdir.

onStart — ekranda paydo bo'lish

onStart() onCreate() dan so'ng yoki onRestart() dan keyin, Activity foydalanuvchiga ko'rinadigan bo'lganda chaqiriladi. Bu holatda Activity hali oldingi planda emas va foydalanuvchi bilan o'zaro aloqada bo'lolmaydi, lekin uning foydalanuvchi interfeysi ekranda ko'rinib turibdi. Masalan, ilovani ishga tushirishda onStart va onResume chaqiruvi o'rtasida tizim interfeysning birinchi kadrini chizadi.

onStart metodida odatda quyidagi harakatlar bajariladi: Activity ko'rinib turganda ishlashi kerak bo'lgan animatsiyalarni boshlash; BroadcastReceiver larni bog'lash; geolokatsiya va sensor xizmatlariga ulanish; ViewModel yoki Room dan ma'lumotlarni yangilash. Shuningdek, bu yerda agar ilova jarayon ichida mijoz-server arxitekturasidan foydalansa, bindService() orqali Bound xizmatlariga ulanish amalga oshiriladi.

override fun onStart() {
    super.onStart()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.requestLocationUpdates(
        LocationManager.GPS_PROVIDER,
        5000L,
        10f,
        locationListener
    )
}

override fun onStop() {
    super.onStop()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.removeUpdates(locationListener)
}

Muhim qoida: onStart da ulangan resurslar onStop da bo'shatilishi kerak. Bu Activity ekranda ko'rinmaganda batareya va tizim resurslarini iste'mol qilmasligini kafolatlaydi. Google Play Store yangilanishlarni moderatsiya qilishda ilovalarni LocationListener va boshqa tizim xizmatlarining oqishi uchun tekshiradi.

onResume — fokus olish

onResume() — Activity oldingi planda joylashgan va foydalanuvchi bilan o'zaro aloqaga tayyor bo'lgan holat. Bu ekranning ish holati: tizim Activity ga kiritish fokusini uzatadi va barcha teginish, klaviatura kiritish va imo-ishora hodisalari ushbu ekranga yo'naltiriladi. onResume metodi Activity oldingi planga qaytgan har safar chaqiriladi — boshqa Activity tugagandan so'ng, dialog oynasi yopilgandan so'ng, qurilma qulfi ochilgandan so'ng.

onResume da bajariladi: onPause da to'xtatilgan animatsiyalarni qayta boshlash; kamera va boshqa eksklyuziv resurslarni ochish; sensor tinglovchilarini ro'yxatdan o'tkazish (akselerometr, giroskop); UI uchun taymerlar va sekundomerni ishga tushirish; ekran tarkibini dolzarb ma'lumotlar bilan yangilash. onResume / onPause juftligida faqat fokusda faol bo'lishi kerak bo'lgan resurslar bilan ishlanadi — masalan, uzluksiz nutqni aniqlash yoki video suratga olish.

override fun onResume() {
    super.onResume()
    cameraHolder.openCamera()
    animator.resume()
    sensorManager.registerListener(
        stepCounter,
        sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER),
        SensorManager.SENSOR_DELAY_NORMAL
    )
}

override fun onPause() {
    super.onPause()
    cameraHolder.closeCamera()
    animator.pause()
    sensorManager.unregisterListener(stepCounter)
}

onStart va onResume o'rtasidagi farq muhim: Activity ko'rinadigan (onStart) bo'lishi mumkin, lekin faol (onResume) bo'lmasligi mumkin — masalan, uning ustida qalqib chiquvchi dialog oynasi yoki shaffof qulf ekrani ko'rsatilganda. Aynan onResume da, onStart da emas, monopol kirish talab qiladigan eksklyuziv resurslarni ochish kerak.

onPause — fokusni yo'qotish

onPause() Activity kiritish fokusini yo'qotganda, lekin qisman ko'rinadigan bo'lib qolganda chaqiriladi. Odatiy stsenariylar: dialog oynasini ochish, «Yaqinda» tugmasini bosish, kiruvchi qo'ng'iroq, «Uy» tugmasini bosish (bu holda onPause dan keyin onStop keladi). onPause metodi — foydalanuvchi yo'qotmasligi kerak bo'lgan ma'lumotlarni saqlash uchun oxirgi ishonchli joy.

onPause da bajariladi: xat qoralamalari va kirish formlarini Room yoki SharedPreferences da saqlash; animatsiyalar va video ijrosini to'xtatish; kamerani yopish va monopol resurslarni bo'shatish; fon uchun muhim bo'lmagan qimmat operatsiyalarni bekor qilish. onPause metodi 100 millisekunddan kamroqda tugashi kerak — tizim onPause boshqaruvni qaytarmaguncha keyingi Activity ga o'tishni bloklaydi va limitdan oshib ketish ANR (Application Not Responding) ga olib keladi.

override fun onPause() {
    super.onPause()
    val editor = SharedPreferences.Manager ...
    editor.putString("draft_text", draftEditText.text.toString())
    editor.apply()
    videoView.pause()
    cameraHolder.release()
}

Muhim: onPause UI ipida bajariladi, shuning uchun sinxron so'rov bilan Room orqali ma'lumotlar bazasiga yozish kabi har qanday blokirovka operatsiyalari asinxron (korutinlar) bilan almashtirilishi yoki fon ipida bajarilishi kerak. SharedPreferences uchun commit() o'rniga apply() dan foydalaning — apply ma'lumotlarni asinxron yozadi va UI ipini bloklamaydi.

onStop — ekrandan yashirinish

onStop() Activity foydalanuvchiga ko'rinmaydigan bo'lganda chaqiriladi. Bu quyidagi hollarda sodir bo'ladi: Activity boshqa Activity bilan to'liq yopilgan; foydalanuvchi «Uy» tugmasini bosgan yoki boshqa ilovaga o'tgan; Activity tugatilmoqda (keyin onDestroy chaqiriladi). onStop holatida Activity xotirada qoladi va barcha maydonlarini saqlaydi — yo'q qilinmagan, lekin faol ham emas.

onStop da bajariladi: onStart da ro'yxatdan o'tkazilgan BroadcastReceiver lardan chiqish; Bound xizmatlaridan uzilish; LocationListener, SensorListener va boshqa tizim tinglovchilarini bo'shatish; ilova yashiringanda kerak bo'lmagan uzoq fon operatsiyalarini to'xtatish; agar bu onPause da qilinmagan bo'lsa, onSaveInstanceState() orqali UI joriy holatini Bundle ga yozish.

override fun onStop() {
    super.onStop()
    unregisterReceiver(connectivityReceiver)
    unbindService(serviceConnection)
    if (isChangingConfigurations()) {
        Log.d("Lifecycle", "Activity konfiguratsiya tufayli qayta yaratiladi")
    }
}

Tizim xotira yetishmaganda onStop holatidagi Activity ni onDestroy chaqirmasdan yo'q qilishi mumkin. Shuning uchun barcha muhim ma'lumotlar onStop ga o'tishdan oldin saqlanishi kerak. isChangingConfigurations() bayrog'i onStop chaqiruvining ekran aylantirish bilan bog'liqligini aniqlash imkonini beradi — bu holda Activity tugatilmaydi, balki qayta yaratiladi.

onDestroy — Activity yo'q qilish

onDestroy() — hayot siklning oxirgi metodi, Activity to'liq yo'q qilinishidan oldin chaqiriladi. Tizim onDestroy ni ikki holatda chaqiradi: Activity finish() chaqiruvi bilan tugatiladi yoki foydalanuvchi «Orqaga» tugmasini bosadi; Activity konfiguratsiya o'zgarishi (masalan, ekran aylantirish) tufayli tizim tomonidan yo'q qilinadi va qayta yaratiladi. onDestroy metodi resurslarni yakuniy tozalashni amalga oshirish imkonini beradi: ip va korutinlarni uzish, doimiy ochiq kursor va soketlarni yopish, NDK orqali mahalliy xotirani bo'shatish.

override fun onDestroy() {
    super.onDestroy()
    backgroundJob.cancel()
    dbHelper.close()
    if (isFinishing) {
        Log.d("Lifecycle", "Activity yakuniy tugatiladi")
    } else {
        Log.d("Lifecycle", "Activity qayta yaratiladi")
    }
}

Muhim eslatma: onDestroy kafolatlanmagan, agar ilova jarayoni tizim tomonidan o'ldirilsa (out-of-memory kill). Shuning uchun ma'lumotlarni saqlash uchun onDestroy ga tayanib bo'lmaydi — bu vazifa onPause yoki onStop da hal qilinadi. isFinishing xususiyati Activity ni finish() bilan tugatishni konfiguratsiya o'zgarishida qayta yaratishdan farqlash imkonini beradi.

onRestart — to'xtatilgan holatdan qaytish

onRestart() onStart() dan oldin, Activity to'xtatilgan holatdan (onStop) oldingi planga qaytganda chaqiriladi. Bu foydalanuvchi ilovani «Yaqinda» menyusidan qayta ochganda yoki bola ekranda «Orqaga» tugmasini bosib Activity ga qaytganda sodir bo'ladi. onRestart metodi onCreate dan farqli mantiqni bajarish imkonini beradi — masalan, Activity yashirin bo'lganida o'zgarishi mumkin bo'lgan ma'lumotlarni yangilash.

override fun onRestart() {
    super.onRestart()
    refreshDataFromNetwork()
    Log.d("Lifecycle", "Activity stekdan qayta ishga tushiriladi")
}

Odatiy stsenariy: foydalanuvchi ilovani ochdi, boshqa vazifaga o'tdi va bir soatdan keyin qaytdi. onRestart da ilova ma'lumotlarning dolzarbligini tekshirishi va agar ko'p vaqt o'tgan bo'lsa, tarkibni qayta yuklashni taklif qilishi mumkin. Bu foydalanuvchi tajribasini yaxshilaydi va eskirgan ma'lumotlarni ko'rsatish ehtimolini kamaytiradi.

Ekran aylantirish va holatni saqlash

Ekran aylantirish — Activity qayta yaratilishining eng keng tarqalgan stsenariysi. Odatiy bo'lib, Android har bir orientatsiya o'zgarishida joriy Activity ni yo'q qiladi va yangisini yaratadi. Agar holat saqlanmasa, foydalanuvchi barcha kiritilgan ma'lumotlarni yo'qotadi. Buning uchun Android ikkita mexanizmni taqdim etadi: onSaveInstanceState() seriyalashtiriladigan ma'lumotlar uchun va ViewModel konfiguratsion o'zgarishlardan omon qoladigan ma'lumotlar uchun.

onSaveInstanceState va onRestoreInstanceState

onSaveInstanceState() Activity yo'q qilinishidan oldin vaqtinchalik holatni saqlash uchun chaqiriladi. Saqlangan ma'lumotlar onCreate ga savedInstanceState parametri orqali va onStart dan keyin chaqiriladigan onRestoreInstanceState() metodiga uzatiladi. Bundle hajm chekloviga ega — taxminan 500 KB, shuning uchun katta hajmdagi ma'lumotlar (masalan, bitmaplar) ViewModel orqali saqlanadi.

<!-- AndroidManifest.xml — orientatsiyani fiksatsiya qilish -->
<activity android:name=".MainActivity"
    android:configChanges="orientation|screenSize" />

android:configChanges orqali orientatsiyani fiksatsiya qilish Activity qayta yaratilishini oldini oladi, ammo agar ilova ikkala orientatsiyani qo'llab-quvvatlashi kerak bo'lsa, bu antipattern hisoblanadi. Google ning zamonaviy tavsiyasi — foydalanuvchi UI ga kiritadigan ma'lumotlar uchun onSaveInstanceState bilan birgalikda ViewModel dan foydalanish.

Fragment hayot sikl

Fragment o'zining hayot sikliga ega, Activity ga o'xshash, lekin qo'shimcha metodlar bilan: onAttach, onCreate, onCreateView, onViewCreated, onStart, onResume, onPause, onStop, onDestroyView, onDestroy, onDetach. Fragment har doim Activity ichida mavjud bo'lib, uning hayot sikl Activity-konteynerining hayot sikl bilan bog'liq. Agar Activity yo'q qilinsa, Fragment unga ergashadi.

Asosiy farq: Fragment nafaqat komponent holatini, balki View ierarxiyasini ham boshqaradi. onCreateView metodi Fragment ning ildiz View sini qaytaradi, onDestroyView esa bu ierarxiyani yo'q qiladi. Bu Fragment ga ekran aylantirilganda Activity qayta yaratilishidan omon qolish imkonini beradi: Fragment saqlanadi, uning View si onCreateView da qayta yaratiladi.

class ProfileFragment : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        return inflater.inflate(R.layout.fragment_profile, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val avatarImage: ImageView = view.findViewById(R.id.avatar_image)
        loadAvatar(avatarImage)
    }
}

onCreate va onCreateView o'rtasidagi farqni tushunish juda muhim: onCreate Fragment hayotida bir marta chaqiriladi (hatto View qayta yaratilganda ham), onCreateView esa har safar Fragment o'z View ierarxiyasini yaratganda yoki qayta yaratganda chaqiriladi. Ma'lumotlarni ishga tushirish onCreate da, UI bog'lash esa onViewCreated da amalga oshiriladi.

LifecycleObserver va Jetpack

LifecycleObserver — Android Jetpack kutubxonasining komponenti bo'lib, Activity yoki Fragment dagi metodlarni qayta yozmasdan hayot sikl o'zgarishlariga reaksiya berish imkonini beradi. Har bir hayot sikl metodida kodni takrorlash o'rniga, ishlab chiquvchi @OnLifecycleEvent annotatsiyalari bilan alohida klass yaratadi va uni lifecycle.addObserver() ga uzatadi.

Jetpack shuningdek LifecycleOwner klassini taqdim etadi — bu AppCompatActivity va Fragment tomonidan amalga oshiriladigan interfeys. LifecycleOwner ni amalga oshiradigan har qanday ob'ekt LiveData obunalarini, lifecycleScope orqali korutinlarni va WorkManager ishini hayot sikl bilan bog'liq holda boshqarishi mumkin. Bu MVVM va Jetpack ga asoslangan zamonaviy Android arxitekturasining tamal toshidir.

class MyLocationObserver(private val context: Context) : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        startLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        stopLocationUpdates()
    }
}

// Activity da:
lifecycle.addObserver(MyLocationObserver(this))

DefaultLifecycleObserver dan foydalanish testlashni soddalashtiradi, kod takrorlanishini kamaytiradi va hayot sikl mantig'ini turli ekranlar o'rtasida qayta foydalanishga yaroqli qiladi. Bu har bir Activity da onStart/onStop ni qo'lda qayta yozishning zamonaviy o'rnini bosuvchi usuldir. IT Sectr tomonidan ishlab chiqilgan Android ilovalarida biz LifecycleObserver ni geolokatsiya, Bluetooth skanerlash va analitika uchun qo'llaymiz — bu boilerplate kod hajmini 30–40% kamaytiradi.