Not Running — bu nima, hayot siklining boshlang'ich holati

Not Running — bu qanday holat

Not Running — mobil ilovaning hayot siklidagi asosiy holat bo'lib, unda ilova qurilmaning RAM xotirasiga yuklanmagan va tizim resurslarini sarf qilmaydi. iOS va Android da bu holat ilova bilan bog'liq jarayon va oqimlarning to'liq yo'qligini anglatadi. Foydalanuvchi ilova belgisini ish stolida ko'radi, lekin ilovaning o'zi faol emas va yaqinda ishlatilganlar ro'yxatida mavjud emas.

Foydalanuvchi belgini bosganda, tizim yangi jarayon yaratadi, bajariladigan kodni xotiraga yuklaydi va barcha kerakli ma'lumotlar tuzilmalarini initsializatsiya qiladi. Bu jarayon sovuq ishga tushirish (cold start) deb ataladi va yuklash vaqti nuqtai nazaridan eng resurs talab qiladiganidir.

Tizim ilovani istalgan boshqa holatdan Not Running ga o'tkazishi mumkin. Agar ilova fonda (Background) yoki to'xtatilgan (Suspended) bo'lsa, operatsion tizim ko'proq ustuvor vazifalar uchun RAM xotira yetishmasligida uni bo'shatish huquqiga ega — masalan, oldingi plandagi faol ilova uchun.

Dasturchi yodda tutishi kerakki, ilova tizim tomonidan istalgan vaqtda tugatilishi mumkin, u fonda bo'lganda. Bu barcha saqlanmagan ma'lumotlar yo'qolishi mumkinligini anglatadi. Shuning uchun Active dan Background ga o'tishlarda holatni kalit-qiymat omborlarida (UserDefaults, SharedPreferences) yoki mahalliy ma'lumotlar bazasida saqlash juda muhimdir.

Tizim qaysi ilovani bo'shatishni qanday aniqlaydi

iOS ilovaning joriy holatiga asoslangan ustuvorliklardan foydalanadi: Active eng yuqori ustuvorlikka ega, keyin Inactive, Background, Suspended va nihoyat Not Running — minimal ustuvorlik. Android shunga o'xshash jarayon iyerarxiyasidan foydalanadi: Foreground jarayoni OOM_ADJ = 0 ustuvorligiga ega, Visible jarayoni = 100, Service jarayoni = 200, Background jarayoni = 300, Empty jarayoni = 400. Qiymat qanchalik yuqori bo'lsa, xotira yetishmasligida jarayonning tugatilish ehtimoli shunchalik yuqori.

Ilovaning sovuq va issiq ishga tushirilishi

Sovuq ishga tushirish (cold start) ilova Not Running dan to'g'ridan-to'g'ri Active ga o'tganda sodir bo'ladi. Tizim yangi jarayon yaratadi, sinflarni yuklaydi, statik maydonlarni initsializatsiya qiladi, asosiy oqimni yaratadi va UI tizimini ishga tushiradi. iOS da bu application(_:didFinishLaunchingWithOptions:) chaqiruvini, Android da esa Application.onCreate() va Activity.onCreate() chaqiruvini anglatadi. Sovuq ishga tushirish vaqti ilovaning murakkabligiga qarab 200 ms dan bir necha soniyagacha bo'lishi mumkin.

Issiq ishga tushirish (warm start yoki hot start) — ilova Suspended holatida bo'lgan va to'liq qayta yuklanmasdan ishga qaytadi. Tizim oxirgi UI stekini xotiradan tiklaydi va foydalanuvchi ishni o'sha joydan davom ettiradi. Issiq ishga tushirish sovuqdan sezilarli darajada tezroq, chunki kodning katta qismi allaqachon xotiraga yuklangan. iOS da issiq ishga tushirish application(_:didFinishLaunchingWithOptions:) ni chaqirmaydi, faqat applicationWillEnterForeground va applicationDidBecomeActive ni chaqiradi.

Sovuq va issiq ishga tushirish o'rtasidagi farq foydalanuvchi tajribasi uchun muhimdir. Sovuq ishga tushirishda dasturchi ishga tushirish imkon qadar tez bo'lishini ta'minlashi kerak — modullarning dangasa initsializatsiyasi, og'ir resurslarning kechiktirilgan yuklanishi, boshlang'ichda asosiy oqimdagi ishni minimallashtirish. Google tavsiya qiladi sovuq ishga tushirish 500 ms dan oshmasligi kerak, Apple — iOS uchun 400 ms dan oshmasligi kerak.

// Android da sovuq ishga tushirish vaqtini o'lchash
class App : Application() {
    private var startTime: Long = 0L

    override fun onCreate() {
        super.onCreate()
        startTime = System.currentTimeMillis()
    }

    fun getStartupTime(): Long {
        return System.currentTimeMillis() - startTime
    }
}

// Activity ni dangasa initsializatsiya bilan ishga tushirish
class MainActivity : AppCompatActivity() {
    private val viewModel: MainViewModel by lazy {
        ViewModelProvider(this).get(MainViewModel::class.java)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // Faqat birinchi kadr uchun zaruriy minimum
        setupNavigation()
    }

    override fun onPostCreate(savedInstanceState: Bundle?) {
        super.onPostCreate(savedInstanceState)
        // Renderdan keyin og'ir initsializatsiya
        initializeHeavyModules()
    }
}

Misolda Android da sovuq ishga tushirish vaqtini o'lchash ko'rsatilgan. Application.onCreate() Not Running dan Active ga o'tishda chaqiriladi. Vaqt tamg'asi jarayonning boshlanishida qayd etiladi. Activity birinchi kadrni bloklamaslik uchun lazy-delegat orqali dangasa initsializatsiyadan foydalanadi. onPostCreate og'ir modullarni initsializatsiya qilish uchun eng maqbul joy, chunki UI allaqachon chizilgan.

iOS da Not Running: Swift va AppDelegate

iOS da Not Running UIApplicationDelegate delegati orqali boshqariladi. Asosiy metodlar: application(_:didFinishLaunchingWithOptions:) sovuq ishga tushirishdan keyin chaqiriladi, applicationWillTerminate(_:) ilovani foydalanuvchi tomonidan tugatilishidan oldin chaqiriladi. Biroq tizim applicationWillTerminate ni chaqirmasdan ilovani tugatishi mumkin — masalan, favqulodda tugatish yoki xotirani bo'shatishda. iOS bu metodning chaqirilishini kafolatlamaydi, shuning uchun ma'lumotlarni applicationDidEnterBackground da saqlash kerak.

iOS da Not Running ga o'tish stsenariylari

Foydalanuvchi qo'lda ilovani App Switcher da surish bilan tugatishi mumkin. Tizim ilovani fonda xotiradan bo'shatishi mumkin. Ilova favqulodda (crash) tugashi mumkin. Barcha holatlarda, ishga tushirish vaqtida yaratilgan barcha obyektlar yo'q qilinadi. Saqlanmagan holat qaytarib bo'lmaydigan darajada yo'qoladi. iOS 13+ da holatni saqlash uchun NSUserActivity yoki UIApplication.stateRestorationIdentifier orqali state restoration mexanizmidan foydalanish tavsiya etiladi.

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    // Sovuq ishga tushirish: ilova Not Running dan o'tdi
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        // Minimal xizmatlar to'plamini initsializatsiya qilish
        setupAnalytics()
        configureAppearance()
        return true
    }

    // Ilova ishni tugatadi — faqat qo'lda yopish
    func applicationWillTerminate(
        _ application: UIApplication
    ) {
        saveCriticalData()
    }

    // Fonga o'tishdan oldin ma'lumotlarni saqlash
    func applicationDidEnterBackground(
        _ application: UIApplication
    ) {
        saveApplicationState()
    }

    private func saveCriticalData() {
        UserDefaults.standard.synchronize()
    }

    private func saveApplicationState() {
        let state = ["lastScreen": "main", "timestamp": Date()]
        try? NSKeyedArchiver.archivedData(
            withRootObject: state,
            requiringSecureCoding: true
        )
    }
}

Kod iOS da Not Running ni to'g'ri boshqarishni ko'rsatadi. applicationWillTerminate faqat foydalanuvchi tomonidan qo'lda tugatishda chaqiriladi. Kritik ma'lumotlarni saqlash applicationDidEnterBackground da takrorlanadi, chunki bu metod fonda o'tishdan oldin chaqirilishi kafolatlangan. State restoration sovuq ishga tushirishda keyinroq tiklash uchun UI stekini saqlashga imkon beradi.

Android da Not Running: Kotlin va jarayon

Android da Not Running ilova jarayoni mavjud emasligini anglatadi. Android asosidagi Linux tizimi jarayonlarni Zygote mexanizmi orqali boshqaradi. Ilova ishga tushirilganda, Zygote yangi jarayonni fork qiladi, Dalvik/ART yuklaydi va Application.onCreate() ni chaqiradi. Android da applicationWillTerminate ning to'g'ridan-to'g'ri analogi yo'q — tizim ogohlantirishsiz istalgan vaqtda jarayonni tugatishi mumkin.

Android jarayonining hayot sikli

Activity birinchi marta chaqirilganda, tizim jarayon, Application va Activity ni onCreate → onStart → onResume zanjiri orqali yaratadi. Agar foydalanuvchi Back tugmasini bossa, Activity yo'q qilinadi (onDestroy) va jarayon tizim tomonidan tugatilishi mumkin. iOS dan asosiy farq: Android da jarayon faol Activity larsiz ham mavjud bo'lishi mumkin — masalan, Foreground Service ishlayotgan bo'lsa yoki faol BroadcastReceiver mavjud bo'lsa.

// ViewModel da SavedStateHandle orqali Not Running ni boshqarish
class MainViewModel(
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {

    companion object {
        private const val KEY_LAST_SCREEN = "last_screen"
        private const val KEY_USER_DATA = "user_data"
    }

    fun saveCurrentState(screen: String, data: String) {
        savedStateHandle[KEY_LAST_SCREEN] = screen
        savedStateHandle[KEY_USER_DATA] = data
    }

    fun restoreState(): AppState? {
        val screen = savedStateHandle.get<String>(KEY_LAST_SCREEN)
        val data = savedStateHandle.get<String>(KEY_USER_DATA)
        return if (screen != null && data != null) {
            AppState(screen, data)
        } else null
    }
}

// Application — Not Running dan keyin birinchi qayta chaqiruv
class MyApplication : Application() {

    override fun onCreate() {
        super.onCreate()
        initCrashReporter()
        initDependencyInjection()
    }
}

SavedStateHandle — Not Running ga o'tishda avtomatik ravishda holatni saqlaydigan va sovuq ishga tushirishda uni tiklaydigan Android Architecture Components komponentidir. ViewModelProvider orqali yaratilgan ViewModel ekran aylanishi va Activity ni yo'q qilinishiga chidaydi. Jarayon tugaganda, SavedStateHandle dan ma'lumotlar Bundle ga seriyalashtiriladi va saved instance state da saqlanadi.

Not Running ga o'tish sabablari

Not Running bir necha sababga ko'ra yuz beradi. Foydalanuvchi qo'lda ilovani yopadi. Tizim xotira yetishmasligida ilovani bo'shatadi. Ilova istisno bilan favqulodda tugaydi. Android da tizim ilovalarning ommaviy yangilanishida yoki qurilma qayta ishga tushirilganda jarayonni tugatishi mumkin. iOS fon vazifasining vaqt tugashida (odatda 30 soniya) ilovani tugatishi mumkin.

Not Running ga o'tishni qanday tashxislash mumkin

iOS uchun applicationWillTerminate va applicationDidFinishLaunching da konsol logidan foydalaning. Har bir ishga tushirishda UserDefaults ga bayroq qo'shing — agar keyingi ishga tushirishda bayroq bo'lmasa, ilova noto'g'ri tugatilgan. Android da ActivityManager.isBackgroundRestricted() dan foydalaning, ilova fon vazifalarini ishga tushira oladimi yoki yo'qmi, tekshirish uchun. Shuningdek, onTrimMemory(TRIM_MEMORY_COMPLETE) ni kuzating — bu jarayon tugatilishiga ishoradir.

Not Running bilan ishlashning eng yaxshi amaliyotlari

Birinchi qoida — hech qachon applicationWillTerminate yoki onDestroy chaqirilishiga ishonmang. Kritik muhim ma'lumotlarni Active dan Background ga har bir o'tishda saqlang. Oddiy sozlamalar uchun kalit-qiymat omborlaridan, tuzilgan ma'lumotlar uchun SQLite/Room dan foydalaning.

Ikkinchi qoida — sovuq ishga tushirish vaqtini o'lchang va optimallashtiring. Dangasa initsializatsiya, asosiy oqimdagi ishni minimallashtirish, resurslarni oldindan yuklash, SplashScreen API dan foydalanish — bularning barchasi ishga tushirish vaqtini idrok qilishni yaxshilaydi. Google tavsiya qiladi ajoyib UX uchun sovuq ishga tushirish 200 ms dan kam bo'lishi kerak.

Uchinchi qoida — State Restoration ni amalga oshiring. iOS da UIApplication.stateRestorationIdentifier va NSUserActivity dan foydalaning. Android da ViewModel da SavedStateHandle ni onSaveInstanceState bilan birgalikda ishlating. Bu foydalanuvchiga ilova qayta ishga tushirilgandan keyin ishni o'sha joydan davom ettirishga imkon beradi.

To'rtinchi qoida — Not Running dan keyin ilova ishga tushirilgan launchOptions va Intent larni boshqaring. Deep link lar, push bildirishnomalari, universal havolalar — bularning barchasi ishga tushirish parametrlari orqali uzatiladi. Dasturchi bu ma'lumotlarni to'g'ri chiqarib olishi va foydalanuvchini tegishli ekranga yo'naltirishi kerak.

// Sovuq ishga tushirishdan keyin deep link ni boshqarish
func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
    // Bildirishnoma kelganligini tekshirish
    if let notification = launchOptions?[.remoteNotification] as? [String: Any] {
        handleNotification(notification)
    }
    // Deep link ni tekshirish
    if let url = launchOptions?[.url] as? URL {
        handleDeepLink(url)
    }
    return true
}

private func handleDeepLink(_ url: URL) {
    guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
          let screenId = components.queryItems?.first(where: { $0.name == "screen" })?.value
    else { return }
    openScreen(screenId)
}

Kod iOS sovuq ishga tushirishida ishga tushirish parametrlarini boshqarishni ko'rsatadi. launchOptions tizim ilovani ishga tushirgan ma'lumotlarni o'z ichiga oladi. Bildirishnomalar, deep link lar va universal havolalar ushbu lug'at orqali uzatiladi. Dasturchi muammosiz foydalanuvchi tajribasini ta'minlash uchun barcha mumkin bo'lgan ishga tushirish stsenariylarini to'g'ri boshqarishi kerak.