Background: asoslar, iOS va Android ilovasining fonda ishlashi

Background — fon holatining asoslari

Background — ilovaning operatsion tizimda mavjud bo'lishda davom etadigan, kod bajaradigan va resurslarni iste'mol qiladigan, lekin qurilma ekranida ko'rsatilmaydigan holati. Foydalanuvchi Bosh ekranda, boshqa ilovada yoki qurilma ekrani bloklangan. iOS da Background Inactive dan keyin keladi — o'tish zanjiri: Active → Inactive → Background. Android da onStop Activity ning Background ga o'tishini bildiradi.

Har ikkala platforma fon ishiga qattiq cheklovlar qo'yadi. iOS Background ga o'tgandan keyin kodni bajarish uchun cheklangan vaqt oynasini (odatda 30 soniya) taqdim etadi, shundan so'ng ilova Suspended holatiga o'tkaziladi. Android moslashuvchanroq: ko'rinadigan bildirishnoma bilan Foreground Service cheksiz ishlashi mumkin, lekin oddiy Background Service bir necha daqiqa bilan cheklangan. Dasturchining asosiy vazifasi — holatni to'g'ri saqlash va tizim fon vazifalari API lari orqali ishni davom ettirishni rejalashtirish.

Tizim xotira yetishmovchiligi bo'lganda fon ilovasini istalgan vaqtda tugatishi mumkin. Tugatishda barcha saqlanmagan ma'lumotlar yo'qoladi. Shuning uchun applicationDidEnterBackground (iOS) yoki onStop (Android) da holatni saqlash juda muhim. Tugatishdan keyin navbatdagi ishga tushirishda ilova Not Running dan sovuq start bilan boshlanadi va saqlangan holatni tiklaydi.

Background vs Suspended

Background va Suspended ni farqlash muhim. Background — ilova faol ravishda kod bajaradi. Suspended — ilova xotirada, lekin kod bajarmaydi — muzlatilgan. iOS da ilova fon vazifalari tugagandan so'ng Background dan Suspended ga o'tadi. Android da Suspended yo'q — jarayon yoki mavjud (fon bilan birga) yoki tugatilgan (Not Running). Biroq Android LMK (Low Memory Killer) orqali thread larning bajarilishini to'xtatishi mumkin.

iOS da Background: Swift, beginBackgroundTask va BGTaskScheduler

iOS da Background applicationDidEnterBackground delegat metodi orqali qayta ishlanadi. Bu metodda dasturchi foydalanuvchi holatini saqlashi, resurslarni bo'shatishi va fon vazifalarini tugatishi kerak. Background ga o'tgandan keyin kodni bajarish uchun beginBackgroundTask(expirationHandler:) ishlatiladi — tizimdan qo'shimcha vaqt (odatda 30 soniya) so'raydigan API. Agar vazifa bu vaqtda tugamasa, expirationHandler chaqiriladi va ilova majburiy ravishda Suspended ga o'tkaziladi.

iOS 13 dan boshlab Apple BGTaskScheduler ni taqdim etdi — fon vazifalarini rejalashtirish uchun zamonaviy API. beginBackgroundTask dan farqli o'laroq, faqat fondan chiqqandan keyin tugatish vaqtini beradi, BGTaskScheduler kelajakda vazifalarni bajarishni rejalashtirishga imkon beradi — masalan, kontentni soatda bir marta yangilash yoki kechasi analitikani yuklash. BGTaskScheduler yangi loyihalar uchun tavsiya etilgan yondashuv, chunki batareya nuqtai nazaridan samaraliroq.

import UIKit
import BackgroundTasks

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    var backgroundTaskID: UIBackgroundTaskIdentifier = .invalid

    // Ilova fonda o'tdi — fon vazifasini boshlaymiz
    func applicationDidEnterBackground(_ application: UIApplication) {
        saveAppState()
        startBackgroundTask()
    }

    private func startBackgroundTask() {
        backgroundTaskID = UIApplication.shared.beginBackgroundTask { [weak self] in
            // Vaqt tugadi — majburiy tugatamiz
            self?.endBackgroundTask()
        }

        // Fon ishini simulyatsiya qilamiz (ma'lumotlarni serverga saqlash)
        DispatchQueue.global().async { [weak self] in
            uploadAnalyticsData()
            self?.endBackgroundTask()
        }
    }

    private func endBackgroundTask() {
        guard backgroundTaskID != .invalid else { return }
        UIApplication.shared.endBackgroundTask(backgroundTaskID)
        backgroundTaskID = .invalid
    }

    // BGTaskScheduler ro'yxatdan o'tkazish
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        BGTaskScheduler.shared.register(
            forTaskWithIdentifier: "com.example.refresh",
            using: nil
        ) { task in
            handleAppRefresh(task: task as! BGAppRefreshTask)
        }
        return true
    }

    func scheduleAppRefresh() {
        let request = BGAppRefreshTaskRequest(identifier: "com.example.refresh")
        request.earliestBeginDate = Date(timeIntervalSinceNow: 3600)
        try? BGTaskScheduler.shared.submit(request)
    }

    func handleAppRefresh(task: BGAppRefreshTask) {
        scheduleAppRefresh()
        task.expirationHandler = { task.setTaskCompleted(success: false) }
        fetchLatestData { result in
            task.setTaskCompleted(success: result)
        }
    }
}

Kod iOS da Background ni to'liq qayta ishlashni ko'rsatadi. applicationDidEnterBackground vaqt chegarasi va expirationHandler bilan beginBackgroundTask orqali fon vazifasini boshlaydi. Parallel ravishda davriy kontent yangilash uchun BGTaskScheduler ro'yxatdan o'tkaziladi. beginBackgroundTask zudlik bilan ishni tugatish uchun, BGTaskScheduler esa uzoq muddatli rejalashtirish uchun ishlatiladi. Har ikkala API vazifa identifikatorlarini to'g'ri boshqarishni talab qiladi.

Android da Background: Kotlin, Service, WorkManager

Android da Background bir nechta API orqali boshqariladi. An'anaviy Service fonda kod bajarishga imkon beradi, lekin Android 8+ (API 26) dan Background Service cheklangan: tizim uni ilova fondan chiqqandan bir necha daqiqa o'tib tugatadi. Doimiy bildirishnoma bilan Foreground Service cheksiz ishlashi mumkin. WorkManager — qurilma qayta yoqilgandan keyin ham bajarilish kafolati bilan fon vazifalari uchun tavsiya etilgan yechim.

Android, iOS dan farqli o'laroq, uzoq muddatli fon jarayonlarini qo'llab-quvvatlaydi. Foreground Service foydalanuvchi ko'rishi kerak bo'lgan vazifalar uchun ishlatiladi — musiqa tinglash, navigatsiya, mashg'ulot yozuvi. JobScheduler va WorkManager — kechiktirilishi mumkin bo'lgan vazifalar uchun: ma'lumotlarni sinxronlash, loglarni yuklash, keshni yangilash. Asosiy farq: Android shartlar bilan vazifalarni rejalashtirishga imkon beradi — Wi-Fi, zaryadlash, qurilmaning harakatsizligi, bu batareya va trafikni tejaydi.

import android.app.Service
import android.content.Intent
import android.os.IBinder
import androidx.work.*

// 1. Uzoq fon ishi uchun Foreground Service
class SyncService : Service() {

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        val notification = createNotification()
        startForeground(NOTIFICATION_ID, notification)
        performBackgroundWork()
        return START_STICKY
    }

    private fun performBackgroundWork() {
        Thread {
            // Ma'lumotlarni server bilan sinxronlash
            syncDataToServer()
            stopForeground(STOP_FOREGROUND_REMOVE)
            stopSelf()
        }.start()
    }

    override fun onBind(intent: Intent?): IBinder? = null
}

// 2. Kechiktirilgan fon vazifalari uchun WorkManager
class DataSyncWorker(
    private val context: Context,
    private val params: WorkerParameters
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        return try {
            // Analitikani serverga yuklash
            uploadAnalytics()
            Result.success()
        } catch (e: Exception) {
            if (runAttemptCount < 3) Result.retry() else Result.failure()
        }
    }
}

// WorkManager vazifasini rejalashtirish
fun scheduleBackgroundSync(context: Context) {
    val constraints = Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)
        .setRequiresBatteryNotLow(true)
        .build()

    val request = OneTimeWorkRequestBuilder<DataSyncWorker>()
        .setConstraints(constraints)
        .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
        .build()

    WorkManager.getInstance(context).enqueue(request)
}

Kod Android da fon ishi uchun ikkita yondashuvni ko'rsatadi. SyncService — zudlik bilan va uzoq fon ishi uchun bildirishnoma bilan Foreground Service. DataSyncWorker — shartlar bilan (Wi-Fi, zaryadlash) kechiktirilgan vazifalar uchun WorkManager. WorkManager qurilma qayta yoqilgandan keyin ham bajarilishni kafolatlaydi va qayta urinishlar uchun exponential backoff ni qo'llab-quvvatlaydi. Foreground Service status panelida doimiy bildirishnomani talab qiladi.

iOS va Android da fon ishining cheklovlari

Har ikkala mobil platforma doimiy ravishda fon ish qoidalarini qattiqlashtiradi. iOS da har bir yangi OS avlodi fonda ish vaqtini qisqartiradi va yangi cheklovlar qo'shadi. Android da Google tobora qattiq energiya tejash rejimlarini joriy qilmoqda (Doze, App Standby). Dasturchi dolzarb cheklovlardan xabardor bo'lishi kerak, aks holda ilova tizim tomonidan muddatidan oldin tugatilishi mumkin.

iOS 13 dan boshlab, tizim fon vaqtidan suiiste'mol qiladigan ilovalar uchun fon vazifalarini o'chiradi. Har bir ilova foydalanuvchi xatti-harakatiga asoslangan holda ma'lum cheklovlar oladi. BGTaskScheduler bajarilishni optimal vaqtga rejalashtiradi — masalan, qurilma Wi-Fi ga ulangan va zaryad olayotganda. BGTaskScheduler dan to'g'ri foydalanadigan ilovalar ko'proq fon vaqti oladi.

Android 9 dan (API 28) boshlab fon ishi qurilma harakatsiz bo'lganda faollashadigan Doze rejimi bilan cheklangan. Doze dagi ilovalar fon vazifalarini bajara olmaydi, tarmoq o'chiriladi, JobScheduler va WorkManager vazifalarni Doze dan chiqquncha kechiktiradi. Foreground Service Doze ni chetlab o'tishning yagona usuli, lekin suiiste'mol qilish ilovaning foydalanuvchi tomonidan bloklanishiga va ruxsatlarning olib tashlanishiga olib keladi.

Fon ishi uchun eng yaxshi amaliyotlar

Birinchi qoida — fonda resurs iste'molini minimallashtiring. Aksariyat fon vazifalarini qurilma zaryad olayotgan va Wi-Fi ga ulangan vaqtga kechiktirish mumkin. Shartlar bilan vazifalarni rejalashtirish uchun BGTaskScheduler (iOS) va WorkManager (Android) dan foydalaning. Fonda og'ir hisob-kitoblarni ishga tushirmang — bu batareyani zaryadsizlantiradi va CPU throttling ga olib keladi.

Ikkinchi qoida — har doim beginBackgroundTask uchun expirationHandler ni belgilang. Agar ilova vazifani belgilangan vaqtda tugatmasa, tizim uni majburiy ravishda Suspended ga o'tkazadi yoki tugatadi. ExpirationHandler ma'lumotlarni saqlash va ishni to'g'ri tugatish uchun so'nggi imkoniyatdir. Android da WorkManager da setForegroundAsync dan foydalaning oddiy vazifani foreground ga aylantirish uchun, agar ko'proq vaqt kerak bo'lsa.

Uchinchi qoida — ishga tushirishdan oldin fon ishi cheklovlarini tekshiring. iOS da qolgan vaqtni tekshirish uchun UIApplication.shared.backgroundTimeRemaining dan foydalaning. Android da ActivityManager.isBackgroundRestricted() ni tekshiring — agar true bo'lsa, ilova fon vazifalarini ishga tushira olmaydi va foydalanuvchiga sozlamalarda cheklovlarni olib tashlashni taklif qilish kerak. Bu ayniqsa muhim fon funksiyalari bo'lgan ilovalar uchun muhim — budilniklar, kalendarlar, sinxronlash.

To'rtinchi qoida — fon vazifalarini haqiqiy qurilmada sinab ko'ring. Simulyator va emulyator haqiqiy fon ishi cheklovlarini aks ettirmaydi. iOS da Xcode da Debug → Simulate Background Fetch dan foydalaning. Android da — adb shell am broadcast -a android.intent.action.ACTION_BOOT_COMPLETED qayta yoqilgandan keyin WorkManager ni test qilish uchun. Batareya darajasi past bo'lgan haqiqiy qurilmada testlar fon ishi muammolarining ko'pchiligini aniqlaydi.

import UIKit

final class BackgroundTaskManager {
    static let shared = BackgroundTaskManager()
    private var tasks: [String: UIBackgroundTaskIdentifier] = [:]

    func startTask(name: String, expiration: @escaping () -> Void) {
        let remaining = UIApplication.shared.backgroundTimeRemaining
        print("Fonda qolgan vaqt: \(remaining) soniya")

        let task = UIApplication.shared.beginBackgroundTask { [weak self] in
            print("Vazifa uchun vaqt tugadi: \(name)")
            expiration()
            self?.endTask(name: name)
        }

        tasks[name] = task
    }

    func endTask(name: String) {
        guard let task = tasks.removeValue(forKey: name),
              task != .invalid
        else { return }
        UIApplication.shared.endBackgroundTask(task)
    }
}

Kod qolgan vaqtni kuzatadigan va identifikatorlarni boshqaradigan fon vazifalari menejerini ko'rsatadi. backgroundTimeRemaining majburiy tugatishgacha bo'lgan soniyalar sonini qaytaradi — agar qiymat cheksiz bo'lsa, ilova cheklovsiz ishlaydi (audio, navigatsiya). Menejer turli nomlar bilan bir nechta fon vazifalarini ishga tushirish va har birini to'g'ri tugatish imkonini beradi. Bunday yondashuv fon vazifalarining oqib ketishini oldini oladi va tizim yopilmagan vazifalar tufayli ilovani tugatmasligini kafolatlaydi.