Active: bu nima, iOS hayot siklidagi Active holati

Active: bu qanday holat

Active — mobil ilovaning hayot siklidagi holat, bunda u oldingi planda bo'ladi, qurilma ekranida ko'rsatiladi va foydalanuvchi bilan faol o'zaro aloqada bo'ladi. Bu holatda ilova barcha teginish hodisalarini, tugma bosishlarni, akselerometr va giroskop ma'lumotlarini qabul qiladi, shuningdek interfeysni renderlash uchun grafik protsessorga to'liq kirish huquqiga ega.

iOS-da Active holati besh holatli hayot sikli modelining bir qismidir: Not Running → Inactive → Active → Inactive → Background → Suspended → Not Running. Android-da analog onResume chaqiruvidan keyingi Activity holatidir, bunda Activity stekning tepasida joylashgan va foydalanuvchi kiritishini qabul qiladi. Active — UI to'liq interaktiv bo'lgan yagona holat va u imo-ishoralarga, siljitishga, bosishlarga va animatsiyalarga reaksiya beradi.

Tizim Active holatidagi ilovaga protsessor va RAM bo'yicha maksimal ustuvorlikni ta'minlaydi. Bu shuni anglatadiki, tizim resurslar yetishmasa ham bunday ilovani tugatmaydi — avval fon va to'xtatilgan jarayonlar tushiriladi. Biroq, ilova batareyani zaryadsizlantirmaslik va CPU throttling-ga sabab bo'lmaslik uchun resurslardan samarali foydalanishi kerak.

Foydalanuvchi uchun Active ilova bilan ishlashning normal holatidir. Foydalanuvchi interfeysni ko'radi, tugmalarni bosishi, formalarni to'ldirishi, lentani siljitishi mumkin. Bu holatning har qanday uzilishi (qo'ng'iroq, bildirishnoma, Control Center uchun yuqoriga surish) ilovani Inactive-ga o'tkazadi, shundan so'ng u Active-ga qaytishi yoki Background-ga o'tishi mumkin.

Tizim ilovaning Active ekanligini qanday aniqlaydi

iOS holatni boshqarish uchun UIApplicationMain-dan foydalanadi. Active-ga o'tishda tizim applicationDidBecomeActive-ni chaqiradi. SwiftUI uchun o'xshash mexanizm — Environment orqali scenePhase-ni kuzatishdir. Android onResume-dan oldingi plandagi Activity faolligi ko'rsatkichi sifatida foydalanadi. Ikkala yondashuv ham kafolatlaydiki, ilova holat o'zgarishi haqida bildirishnoma oladi va o'z xatti-harakatini moslashtira oladi.

iOS-da Active: Swift, UIKit va SwiftUI

iOS-da Active holati UIApplicationDelegate orqali qayta ishlanadi. Asosiy metod — applicationDidBecomeActive(_:). U ilovaning birinchi marta ishga tushirilishida va Inactive-dan qaytishda chaqiriladi. Bu metod Inactive-ga o'tishda to'xtatilgan vazifalarni tiklash uchun ideal joy: animatsiyalarni ishga tushirish, taymerlarni tiklash, sensorlarni qayta ishga tushirish, serverdagi ma'lumotlar yangilanishini tekshirish.

UIKit: AppDelegate va SceneDelegate

iOS 13 dan boshlab Apple iPad-da bir nechta oynalarni qo'llab-quvvatlash uchun UISceneDelegate-ni taqdim etdi. Bu holda applicationDidBecomeActive har bir sahna uchun sceneDidBecomeActive bilan almashtiriladi. Faqat bitta ekranni qo'llab-quvvatlaydigan ilovalar UIApplicationDelegate-dan foydalanishni davom ettirishi mumkin. Ikkala yondashuv ham ilova yoki sahna faol bo'lganda chaqiriladi.

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    // Ilova faol bo'ldi — vazifalarni tiklaymiz
    func applicationDidBecomeActive(_ application: UIApplication) {
        resumeAnimations()
        restartTimers()
        refreshDataIfNeeded()
        startObservingSensors()
    }

    // Ilova faolligini yo'qotadi — to'xtatamiz
    func applicationWillResignActive(_ application: UIApplication) {
        pauseAnimations()
        stopTimers()
        saveDraftData()
    }

    private func resumeAnimations() {
        UIView.animate(withDuration: 0.3) {
            // UI animatsiyalarini tiklash
        }
    }

    private func refreshDataIfNeeded() {
        let lastRefresh = UserDefaults.standard.object(forKey: "lastRefresh") as? Date ?? .distantPast
        if Date().timeIntervalSince(lastRefresh) > 300 {
            fetchDataFromServer()
        }
    }
}

Kod UIKit-da Active-ni to'g'ri qayta ishlashni ko'rsatadi. applicationDidBecomeActive animatsiyalar, taymerlarni tiklaydi va ma'lumotlar yangilanishi kerakligini tekshiradi. applicationWillResignActive resurs sarflashi mumkin bo'lgan hamma narsani to'xtatadi va qoralamalarni saqlaydi. Bunday metodlar juftligi ilovaning holat o'zgarishiga to'g'ri reaksiya berishini kafolatlaydi.

SwiftUI: scenePhase

SwiftUI-da AppDelegate yo'q — holatni boshqarish Environment<ScenePhase> orqali amalga oshiriladi. .active qiymati sahna oldingi planda va interaktiv bo'lganda o'rnatiladi. SwiftUI Active-ga qaytishda animatsiyalar va yangilanishlarni avtomatik ravishda qayta ishga tushiradi. Dasturchi faqat onChange-ga obuna bo'lishi kerak yon ta'sirlarni bajarish uchun.

import SwiftUI

@main
struct ActiveDemoApp: App {
    @Environment(\.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { oldPhase, newPhase in
            switch newPhase {
            case .active:
                print("Sahna faol bo'ldi")
                resumeWork()
            case .inactive:
                print("Sahna faol emas bo'ldi")
                pauseWork()
            case .background:
                print("Sahna fon-ketdi")
                saveState()
            @unknown default:
                break
            }
        }
    }

    private func resumeWork() {
        // Network so'rovlari, animatsiyalarni tiklash
    }

    private func pauseWork() {
        // Vaqtga sezgir vazifalarni to'xtatish
    }

    private func saveState() {
        // Ilova holatini saqlash
    }
}

SwiftUI-da scenePhase ilova holati haqidagi yagona haqiqat manbaidir. onChange har bir o'tishda harakatlarni bajarishga imkon beradi. Esda tutish kerakki, scenePhase faqat iOS 14+ va SwiftUI Lifecycle-da mavjud. SwiftUI ekranlari bo'lgan UIKit ilovalari uchun UIApplicationDelegate yondashuvidan foydalaning.

Active holatiga o'tishlar

Active bir necha yo'l bilan erishiladi. Birinchi va eng ravshan — sovuq ishga tushirish: foydalanuvchi ikonani bosadi, ilova Not Running-dan Inactive orqali Active-ga o'tadi. Ikkinchi — fondan qaytish: foydalanuvchi App Switcher orqali ilovaga qaytadi, ilova Inactive-dan o'tib Active bo'ladi. Uchinchi — vaqtinchalik uzilishdan qaytish: foydalanuvchi qo'ng'iroqni tugatadi, Control Center-ni yopadi yoki bildirishnomaga javob beradi — ilova Inactive-dan Active-ga qaytadi.

Active-ga o'tish zanjiri

Not Running → Inactive → Active — sovuq ishga tushirish. Background → Inactive → Active — fondan qaytish. Inactive → Active — vaqtinchalik uzilishdan qaytish. Har bir holatda applicationDidBecomeActive chaqiriladi, ammo kontekst farq qilishi mumkin. Sovuq ishga tushirishda Active-dan oldin didFinishLaunchingWithOptions chaqiriladi, fondan qaytishda — willEnterForeground. Dasturchi bu farqlardan holatni tiklash strategiyasini tanlash uchun foydalanishi mumkin.

Muhim eslatma: Suspended-dan qaytishda iOS didFinishLaunchingWithOptions-ni chaqirmaydi, chunki ilova allaqachon xotiraga yuklangan edi. Bu shuni anglatadiki, ushbu metodga joylashtirilgan inicializatsiya kodi qayta bajarilmaydi. Dasturchilar ko'pincha buni unutadi va muhim mantiqni ikkala ssenariy uchun applicationWillEnterForeground yoki applicationDidBecomeActive-ga ko'chiradi.

Android-da Active: Activity hayot sikli

Android-da Active-ning analogi onResume() chaqiruvidan keyingi Activity holatidir. Activity faol deb hisoblanadi, agar u oldingi planda bo'lsa va foydalanuvchi kiritishini qabul qilsa. Bu holat Activity stekining tepasiga mos keladi. Agar boshqa Activity tepada paydo bo'lsa (hatto qisman), joriy Activity onPause holatiga o'tadi — iOS Inactive-ning analogi.

Android-ning asosiy farqi — multi-window rejimida (split screen, freeform) bir nechta Activity bir vaqtning o'zida faol bo'lishi mumkin. Bu holda foydalanuvchi o'zaro aloqada bo'lgan Activity faol, qo'shni esa to'xtatilgan (onPause) hisoblanadi. iOS iPhone-da multi-window-ni qo'llab-quvvatlamaydi, faqat iPad-da UIScene orqali.

class MainActivity : AppCompatActivity() {

    override fun onResume() {
        super.onResume()
        // Ilova faol bo'ldi — vazifalarni tiklaymiz
        resumeCameraPreview()
        startLocationUpdates()
        activateSensors()
    }

    override fun onPause() {
        super.onPause()
        // Ilova faolligini yo'qotadi — resurslarni bo'shatamiz
        releaseCamera()
        stopLocationUpdates()
        deactivateSensors()
    }

    private fun resumeCameraPreview() {
        // Kamera oldindan ko'rishni ishga tushirish (ruxsat talab qiladi)
        cameraProvider?.unbindAll()
        cameraProvider?.bindToLifecycle(
            this,
            cameraSelector,
            preview,
            imageAnalyzer
        )
    }

    private fun startLocationUpdates() {
        val locationRequest = LocationRequest.Builder(
            Priority.PRIORITY_HIGH_ACCURACY, 5000
        ).build()
        locationClient.requestLocationUpdates(
            locationRequest,
            locationCallback,
            Looper.getMainLooper()
        )
    }
}

Kod Android-da Active-ni onResume/onPause orqali qayta ishlashni ko'rsatadi. onResume kamera bilan ishlashni, geolokatsiya va sensorlarni tiklaydi — faqat ilova foydalanuvchiga ko'rinadigan bo'lganda faol bo'lishi kerak bo'lgan resurslar. onPause batareyani sarflamaslik uchun bu resurslarni bo'shatadi. CameraX lifecycle-aware API onPause da avtomatik ravishda oldindan ko'rishni to'xtatadi.

Active-ni qayta ishlashning eng yaxshi amaliyotlari

Birinchi qoida — applicationDidBecomeActive yoki onResume da og'ir operatsiyalarni bajarmang. Ma'lumotlarni yuklash, JSON ni pars qilish, ma'lumotlar bazasi bilan ishlash — bularning barchasi asinxron bo'lishi va asosiy oqimni bloklamasligi kerak. Fon vazifalari uchun iOS-da GCD (DispatchQueue), Kotlin-da Coroutines dan foydalaning. Asosiy oqim faqat UI-ni yangilashi va asinxron operatsiyalarni ishga tushirishi kerak.

Ikkinchi qoida — Active-ga har bir qaytishda holatni sinxronlashtiring. Foydalanuvchi tizim ilovasida sozlamalarni o'zgartirgan, push-bildirishnoma olgan yoki boshqa ilovada ma'lumotlarni yangilagan bo'lishi mumkin. Active-ga o'tishda keshning dolzarbligini tekshiring — ehtimol ma'lumotlar foydalanuvchi yo'qligida eskirgan bo'lishi mumkin.

Uchinchi qoida — Active-ga yagona holat sifatida ishonmang. Ilova Active-ni o'tkazib yuborib, to'g'ridan-to'g'ri Not Running-dan Background-ga o'tishi mumkin (fon rejimida ishga tushirilsa). iOS-da bu content-available opsiyasi bilan push-bildirishnoma orqali ishga tushirishda sodir bo'ladi. Android-da — BroadcastReceiver orqali ishga tushirishda. UI operatsiyalarini bajarishdan oldin har doim joriy holatni tekshiring.

To'rtinchi qoida — Android-da onActivityResult o'rniga Activity Result API-dan foydalaning. Bu kamera, galereya yoki ruxsatlarni chaqirish natijasini to'g'ridan-to'g'ri Active holatida Activity qayta yaratilganda ma'lumot yo'qotmasdan qayta ishlashga imkon beradi. iOS uchun tizim dialoglari uchun async/await bilan UIApplication.shared.open dan foydalaning.

import UIKit

final class ActiveStateManager {
    static let shared = ActiveStateManager()
    private var isActive = false

    func setActive(_ active: Bool) {
        isActive = active
        if active {
            NotificationCenter.default.post(name: .appDidBecomeActive, object: nil)
        }
    }

    func performWhenActive(_ block: @escaping () -> Void) {
        if isActive {
            block()
        } else {
            // Bajarishni Active-ga qaytguncha kechiktir
            NotificationCenter.default.addObserver(
                forName: .appDidBecomeActive,
                object: nil,
                queue: .main
            ) { _ in
                block()
            }
        }
    }
}

extension Notification.Name {
    static let appDidBecomeActive = Notification.Name("appDidBecomeActive")
}

Kod ilovaning boshqa komponentlariga joriy faol holatni tekshirishga imkon beruvchi Active holati menejerini ko'rsatadi. performWhenActive yoki blokni darhol bajaradi (ilova faol bo'lsa) yoki bajarishni Active-ga qaytishgacha kechiktiradi. Bu foydalanuvchi ilovaga qaytganidan keyin harakatni bajarishi kerak bo'lgan xizmatlar uchun foydalidir.