Background Task: asosiy tushunchalar, vazifalarni ro'yxatdan o'tkazish va fonda bajarish

iOS da Background Task nima?

Background Task — bu ilovaga fon rejimiga o'tgandan so'ng bajarish vaqtini uzaytirish imkonini beruvchi dasturiy mexanizmdir. Foydalanuvchi ilovani yopganda, tizim UIApplicationDelegate.applicationDidEnterBackground ni chaqiradi. Agar shu paytda muhim operatsiya (ma'lumotlarni saqlash, so'rov yuborish) bajarilayotgan bo'lsa, ilova beginBackgroundTask orqali qo'shimcha vaqt so'rashi mumkin.

Nima uchun Background Tasks kerak

Background Task dan foydalanmasdan, ilova fonga o'tgandan 3-5 soniya o'tgach majburiy to'xtatiladi. Barcha tugallanmagan operatsiyalar uziladi: ma'lumotlar saqlanmaydi, tarmoq so'rovlari uziladi, holatlar yo'qoladi. Background Task ilovaga ushbu operatsiyalarni to'g'ri yakunlash uchun 30 soniyagacha vaqt beradi.

• Holatni saqlash — ma'lumotlarni CoreData, UserDefaults yoki fayl tizimiga yozish.
• Tarmoq so'rovlarini yakunlash — serverdan javobni kutish va natijani qayta ishlash.
• Analitikani yuborish — to'xtatilishdan oldin hodisalarni analitika serveriga uzatish.
• Resurslarni tozalash — fayl deskriptorlarini yopish, xotirani bo'shatish.
• Keshlash — keyingi ishga tushirishda tiklash uchun oraliq natijalarni yozish.

Tarix va evolyutsiya

beginBackgroundTask iOS 4.0 da — ko'p vazifalilikni qo'llab-quvvatlovchi birinchi relizda paydo bo'ldi. iOS 4 dan oldin ilova Home tugmasi bosilganda butunlay yopilardi. iOS 7 dan boshlab Background Fetch va URLSession background configuration paydo bo'ldi. iOS 13 dan boshlab, Apple yangi loyihalar uchun BGTaskScheduler ni tavsiya qiladi, ammo beginBackgroundTask qisqa muddatli operatsiyalar uchun dolzarbligini saqlab qoladi.

beginBackgroundTask qanday ishlaydi: hayot sikli

beginBackgroundTask — UIApplication ning vazifani ro'yxatdan o'tkazadigan va noyob UIBackgroundTaskIdentifier identifikatorini qaytaradigan metodi. Tizim fon bajarish taymerini oshiradi. Vaqt tugagach, expiration handler chaqiriladi, shundan so'ng ilova to'g'ri yakunlash uchun endBackgroundTask(identifier:) ni chaqirishi kerak.

Bosqichma-bosqich bajarish jarayoni

1-qadam — ilova didEnterBackground xabarnomasini oladi. 2-qadam — beginBackgroundTask(expirationHandler:) chaqiriladi. 3-qadam — muhim operatsiya (saqlash, tarmoq so'rovi) bajariladi. 4-qadam — tugagach endBackgroundTask(identifier:) chaqiriladi. Agar operatsiya 30 soniya ichida tugamasa — tizim expiration handler ni chaqiradi va ilova vazifani darhol yakunlashi kerak.

var backgroundTaskID: UIBackgroundTaskIdentifier = .invalid

func startBackgroundTask() {
    backgroundTaskID = UIApplication.shared.beginBackgroundTask {
        // Expiration handler
        UIApplication.shared.endBackgroundTask(backgroundTaskID)
        backgroundTaskID = .invalid
    }
}

func finishBackgroundTask() {
    UIApplication.shared.endBackgroundTask(backgroundTaskID)
    backgroundTaskID = .invalid
}

UIApplication.shared.backgroundTimeRemaining

backgroundTimeRemaining xususiyati fon vazifasining majburiy yakunlanishigacha qolgan soniyalar sonini qaytaradi. Qiymat real vaqtda kamayadi. Agar ilova fonda bo'lmasa — DBL_MAX qaytaradi. Xatti-harakatni moslashtirish uchun ushbu xususiyatdan foydalaning: 5 soniyadan kam qolganda uzoq muddatli operatsiyalarni to'xtating va taraqqiyotni saqlang.

Bir nechta vazifalar

Ilova bir vaqtning o'zida bir nechta Background Task ni ro'yxatdan o'tkazishi mumkin. Har bir vazifa o'z identifikatorini oladi. Umumiy bajarish vaqti yig'iladi — agar 3 ta vazifa ro'yxatdan o'tkazilgan bo'lsa, ilova 90 soniyagacha vaqt olishi mumkin. Biroq, resurslar tugasa yoki batareya chegarasi oshib ketsa, tizim ilovani ertaroq yakunlashi mumkin.

Expiration handler: yakunlashni majburiy qayta ishlash

Expiration handler — bu fon vazifasi uchun ajratilgan vaqt tugaganda tizim tomonidan chaqiriladigan kod bloki. Expiration handler ning mavjudligi Apple ning majburiy talabidir. Usiz ilova tizim tomonidan majburiy yakunlanishi mumkin va ma'lumotlar yo'qolishi mumkin.

Expiration handler da nima bo'lishi kerak

Expiration handler ilova holatini saqlash uchun minimal harakatlarni bajarishi kerak: joriy ma'lumotlarni doimiy xotiraga saqlash, tegishli identifikator bilan endBackgroundTask ni chaqirish va identifikatorni .invalid ga o'rnatish. Expiration handler ichida yangi uzoq muddatli operatsiyalarni boshlash taqiqlanadi — bajarish vaqti 1-2 soniya bilan cheklangan.

func handleExpiration() {
    // Bajarish taraqqiyotini saqlaymiz
    saveProgressToUserDefaults()

    // Faol tarmoq so'rovlarini bekor qilamiz
    currentTask?.cancel()

    // Background Task ni yakunlaymiz
    UIApplication.shared.endBackgroundTask(backgroundTaskID)
    backgroundTaskID = .invalid
}

// Expiration handler bilan ro'yxatdan o'tkazish
backgroundTaskID = UIApplication.shared.beginBackgroundTask(
    withName: "SaveDocument",
    expirationHandler: handleExpiration
)

Expiration handler bilan ishlashdagi xatolar

Eng keng tarqalgan xato — expiration handler ichida endBackgroundTask ni chaqirmaslik. Bunday holda tizim vazifani faol deb hisoblashda davom etadi, ilova Suspended holatiga o'tmaydi va batareya zaryadsizlanadi. Ikkinchi xato — expiration handler ichida uzoq muddatli operatsiyalarni boshlash. Tizim ular tugashidan oldin ilovani yakunlashi mumkin va ma'lumotlar yo'qoladi.

Qolgan vaqtni tekshirish

Expiration handler da bajarish vaqti juda qisqa — odatda 1 soniyadan kam. Shuning uchun handler ichida quyidagilarni bajarib bo'lmaydi: murakkab hisob-kitoblar, tarmoq so'rovlari, CoreData ga katta hajmdagi ma'lumotlarni yozish. Faqat atomik operatsiyalar: UserDefaults da bitta kalitni yozish, holat bayrog'ini o'rnatish, endBackgroundTask chaqiruvi.

Swift da Background Task kod namunalari

Ilova fonga o'tganda hujjatni saqlash uchun Background Task ning to'liq amalga oshirilishini ko'rib chiqamiz. Misol vazifani ro'yxatdan o'tkazish, qolgan vaqtni tekshirish bilan operatsiyani bajarish va endBackgroundTask orqali to'g'ri yakunlashni o'z ichiga oladi.

Hujjatni taraqqiyot bilan saqlash

Fonga o'tganda, ilova katta hujjatni saqlashni boshlaydi. Background Task operatsiya uchun 30 soniyagacha vaqt beradi. Vaqt tugasa — expiration handler oraliq natijalarni saqlaydi. Saqlash tugagandan so'ng resurslarni bo'shatish uchun endBackgroundTask chaqiriladi.

class DocumentManager {
    private var backgroundTaskID: UIBackgroundTaskIdentifier = .invalid

    func saveDocumentInBackground(document: Document) {
        backgroundTaskID = UIApplication.shared.beginBackgroundTask {
            self.saveProgress(document)
            self.endBackgroundTask()
        }

        DispatchQueue.global().async {
            document.save()
            self.endBackgroundTask()
        }
    }

    private func endBackgroundTask() {
        UIApplication.shared.endBackgroundTask(backgroundTaskID)
        backgroundTaskID = .invalid
    }
}

Ma'lumotlarni serverga yuborish

Fonda tarmoq so'rovlari alohida e'tibor talab qiladi — expiration handler javob olinmasdan oldin so'rovni uzishi mumkin. URLSession dan dataTask bilan foydalaning va yuborishdan oldin backgroundTimeRemaining ni tekshiring. 5 soniyadan kam qolgan bo'lsa — yuborishni ilovaning keyingi uyg'onishiga qoldiring.

func sendCriticalData(data: Data) {
    backgroundTaskID = UIApplication.shared.beginBackgroundTask {
        // Qayta yuborish uchun ma'lumotlarni saqlaymiz
        saveForRetry(data)
        self.endBackgroundTask()
    }

    let task = URLSession.shared.dataTask(with: request) { _, _, error in
        if error != nil {
            saveForRetry(data)
        }
        self.endBackgroundTask()
    }
    task.resume()
}

Qolgan vaqtni kuzatish

Uzoq muddatli operatsiyalar uchun UIApplication.shared.backgroundTimeRemaining ni kuzating. Qiymat chegaradan (10 soniya) pastga tushsa, joriy operatsiyani to'xtating va oraliq natijalarni saqlashni boshlang. Bu expiration handler majburiy chaqirilishidan oldin ishni to'g'ri yakunlash imkonini beradi.

Background Task dan foydalanishning eng yaxshi amaliyotlari

Background Task kuchli mexanizmdir, ammo undan noto'g'ri foydalanish batareya va ishlash muammolariga olib keladi. Apple tavsiyalariga va jamiyat tomonidan tasdiqlangan amaliyotlarga rioya qilish odatiy xatolardan qochish va ilovaning barqaror ishlashini ta'minlashga yordam beradi.

Bajarish vaqtini minimallashtirish

Background Task ni imkon qadar tez yakunlang. Fon bajarishning har bir soniyasi batareya quvvatini sarflaydi. Optimal vaqt — 5 soniyadan kam. Agar operatsiya uzoqroq davom etsa — BGTaskScheduler yoki Background Modes dan foydalanishni ko'rib chiqing. Haqiqiy ehtiyojsiz beginBackgroundTask chaqiruvlari orqali vazifani sun'iy ravishda uzaytirmang.

Identifikatorlardan to'g'ri foydalanish

UIBackgroundTaskIdentifier ni sinf yoki strukturaning xususiyati sifatida saqlang. Uni hech qachon global o'zgaruvchi sifatida uzatmang — bu bir nechta vazifalarda ziddiyatlarga olib keladi. Ikki marta yakunlashning oldini olish uchun endBackgroundTask chaqiruvidan keyin identifikatorni .invalid ga o'rnating.

Background Task ni test qilish

Xcode Simulator da ilovani Home tugmasi (Command + Shift + H) orqali fonga o'tkazing. Fon uyg'onishini test qilish uchun Debug — Simulate Background Fetch dan foydalaning. Vaqt tugashini simulyatsiya qilish uchun BACKGROUND_TASK_SIMULATE_EXPIRATION = YES muhit o'zgaruvchisini o'rnating — expiration handler 5 soniyadan so'ng chaqiriladi.

// Operatsiyani boshlashdan oldin qolgan vaqtni tekshirish
let remaining = UIApplication.shared.backgroundTimeRemaining
guard remaining > 10.0 else {
    // Vaqt yetarli emas — vazifani qoldir
    scheduleForNextLaunch()
    return
}

// Vaqt nazorati bilan operatsiyani bajarish
backgroundTaskID = UIApplication.shared.beginBackgroundTask {
    saveProgress()
    self.endBackgroundTask()
}

Retain cycle lardan saqlaning

Expiration handler self ni ushlaydi — agar backgroundTaskID bir xil ob'ektning xususiyati sifatida saqlansa, bu retain cycle yaratishi mumkin. Yopilishda [weak self] dan foydalaning yoki identifikatorni alohida saqlang. Retain cycle xotira sizib ketishiga olib keladi — ob'ekt ilova tugaguniga qadar bo'shatilmaydi.

Background Task vs BGTaskScheduler: yondashuvlarni taqqoslash

iOS 13 chiqishi bilan Apple eski Background Task API ning zamonaviy o'rnini bosuvchi BGTaskScheduler ni taqdim etdi. Ikkala mexanizm ham o'xshash vazifalarni hal qiladi, ammo BGTaskScheduler ko'proq nazorat va moslashuvchanlikni ta'minlaydi. Farqlarni tushunish muayyan stsenariy uchun to'g'ri vositani tanlashga yordam beradi.

Qachon Background Task dan foydalanish kerak

beginBackgroundTask fonga o'tganda darhol bajarilishi kerak bo'lgan qisqa muddatli operatsiyalar uchun mos keladi: holatni saqlash, tarmoq so'rovini yakunlash, ma'lumotlarni keshlash. API sodda va Info.plist sozlamasini yoki identifikatorlarni ro'yxatdan o'tkazishni talab qilmaydi. 10 soniyadan kam davom etadigan operatsiyalar uchun idealdir.

Qachon BGTaskScheduler dan foydalanish kerak

BGTaskScheduler istalgan qulay vaqtda bajarilishi mumkin bo'lgan vazifalar uchun mos keladi: davriy sinxronizatsiya, keshni tozalash, vidjetlarni yangilash. Tizim foydalanuvchi xatti-harakati va batareya holatini hisobga olgan holda optimal vaqtni o'zi tanlaydi. Uzoq muddatli operatsiyalar (10 daqiqagacha) uchun BGProcessingTask dan foydalaning.

Birgalikda foydalanish

Ikkala API dan bitta ilovada foydalanish mumkin. Background Task — fonga o'tganda darhol operatsiyalar uchun (qoralama saqlash). BGTaskScheduler — rejalashtirilgan yangilanishlar uchun (har 6 soatda sinxronizatsiya). Mas'uliyatni taqsimlash ma'lumotlarni to'g'ri saqlash va energiya samarali fon xizmatini kafolatlash imkonini beradi.