Background: základy, práce aplikace na pozadí v iOS a Android

Background — základy stavu na pozadí

Background — stav aplikace, ve kterém nadále existuje v operačním systému, vykonává kód a spotřebovává zdroje, ale není zobrazena na obrazovce zařízení. Uživatel je na domovské obrazovce, v jiné aplikaci nebo je obrazovka zařízení uzamčena. V iOS Background následuje po Inactive — řetězec přechodu: Active → Inactive → Background. V Android onStop signalizuje přechod Activity do Background.

Obě platformy ukládají přísná omezení na práci na pozadí. iOS poskytuje omezené okno (obvykle 30 sekund) pro vykonávání kódu po přechodu do Background, poté je aplikace převedena do Suspended. Android je flexibilnější: Foreground Service s viditelným oznámením může pracovat neomezeně, ale běžný Background Service je omezen na několik minut. Klíčovým úkolem vývojáře — správně uložit stav a naplánovat pokračování práce prostřednictvím systémových API úloh na pozadí.

Systém může ukončit aplikaci na pozadí kdykoli při nedostatku paměti. Při ukončení dojde ke ztrátě všech neuložených dat. Proto je kriticky důležité ukládat stav v applicationDidEnterBackground (iOS) nebo onStop (Android). Po ukončení při příštím spuštění aplikace startuje z Not Running se studeným startem a obnoví uložený stav.

Background vs Suspended

Je důležité rozlišovat Background a Suspended. Background — aplikace aktivně vykonává kód. Suspended — aplikace je v paměti, ale nevykonává kód — je zmrazena. V iOS aplikace přechází z Background do Suspended po dokončení úloh na pozadí. V Android neexistuje Suspended — proces buď existuje (včetně pozadí) nebo je ukončen (Not Running). Android však může pozastavit provádění vláken prostřednictvím LMK (Low Memory Killer).

Background v iOS: Swift, beginBackgroundTask a BGTaskScheduler

V iOS je Background zpracováván prostřednictvím delegátní metody applicationDidEnterBackground. V této metodě by měl vývojář uložit stav uživatele, uvolnit zdroje a dokončit úlohy na pozadí. Pro vykonávání kódu po přechodu do Background se používá beginBackgroundTask(expirationHandler:) — API, které žádá systém o dodatečný čas (obvykle 30 sekund). Pokud úloha není v tomto čase dokončena, je volán expirationHandler a aplikace je násilně převedena do Suspended.

Od iOS 13 Apple představil BGTaskScheduler — moderní API pro plánování úloh na pozadí. Na rozdíl od beginBackgroundTask, který dává čas pouze na dokončení po přechodu na pozadí, BGTaskScheduler umožňuje naplánovat provedení úloh v budoucnosti — například aktualizaci obsahu jednou za hodinu nebo nahrávání analytiky v noci. BGTaskScheduler je doporučený přístup pro nové projekty, protože je efektivnější z hlediska baterie.

import UIKit
import BackgroundTasks

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    var backgroundTaskID: UIBackgroundTaskIdentifier = .invalid

    // Aplikace přešla na pozadí — spouštíme úlohu na pozadí
    func applicationDidEnterBackground(_ application: UIApplication) {
        saveAppState()
        startBackgroundTask()
    }

    private func startBackgroundTask() {
        backgroundTaskID = UIApplication.shared.beginBackgroundTask { [weak self] in
            // Čas vypršel — násilně ukončujeme
            self?.endBackgroundTask()
        }

        // Simulujeme práci na pozadí (ukládání dat na server)
        DispatchQueue.global().async { [weak self] in
            uploadAnalyticsData()
            self?.endBackgroundTask()
        }
    }

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

    // Registrace BGTaskScheduler
    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)
        }
    }
}

Kód ukazuje kompletní zpracování Background v iOS. applicationDidEnterBackground spouští úlohu na pozadí prostřednictvím beginBackgroundTask s časovým limitem a expirationHandler. Paralelně je registrován BGTaskScheduler pro periodickou aktualizaci obsahu. beginBackgroundTask se používá pro okamžité dokončení práce, BGTaskScheduler — pro dlouhodobé plánování. Obě API vyžadují správnou správu identifikátorů úloh.

Background v Android: Kotlin, Service, WorkManager

V Android je Background spravován prostřednictvím několika API. Tradiční Service umožňuje vykonávat kód na pozadí, ale od Android 8+ (API 26) je Background Service omezen: systém jej ukončí několik minut po přechodu aplikace na pozadí. Foreground Service s trvalým oznámením může pracovat neomezeně. WorkManager — doporučené řešení pro úlohy na pozadí se zárukou provedení i po restartu zařízení.

Android na rozdíl od iOS podporuje dlouhotrvající procesy na pozadí. Foreground Service se používá pro úlohy, které uživatel musí vidět — přehrávání hudby, navigace, záznam tréninku. JobScheduler a WorkManager — pro úlohy, které lze odložit: synchronizace dat, nahrávání logů, aktualizace mezipaměti. Klíčový rozdíl: Android umožňuje plánovat úlohy s podmínkami — Wi-Fi, nabíjení, neaktivita zařízení, což šetří baterii a přenos dat.

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

// 1. Foreground Service pro dlouhou práci na pozadí
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 {
            // Synchronizace dat se serverem
            syncDataToServer()
            stopForeground(STOP_FOREGROUND_REMOVE)
            stopSelf()
        }.start()
    }

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

// 2. WorkManager pro odložené úlohy na pozadí
class DataSyncWorker(
    private val context: Context,
    private val params: WorkerParameters
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        return try {
            // Nahrávání analytiky na server
            uploadAnalytics()
            Result.success()
        } catch (e: Exception) {
            if (runAttemptCount < 3) Result.retry() else Result.failure()
        }
    }
}

// Plánování úlohy WorkManager
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)
}

Kód ukazuje dva přístupy k práci na pozadí v Android. SyncService — Foreground Service s oznámením pro okamžitou a dlouhou práci na pozadí. DataSyncWorker — WorkManager pro odložené úlohy s podmínkami (Wi-Fi, nabíjení). WorkManager zaručuje provedení i po restartu zařízení a podporuje exponential backoff pro opakované pokusy. Foreground Service vyžaduje trvalé oznámení ve stavovém řádku.

Omezení práce na pozadí v iOS a Android

Obě mobilní platformy neustále zpřísňují pravidla práce na pozadí. V iOS každá nová generace OS zkracuje dobu práce na pozadí a přidává nová omezení. V Android Google zavádí stále přísnější režimy úspory energie (Doze, App Standby). Vývojář musí být informován o aktuálních omezeních, aby aplikace nebyla předčasně ukončena systémem.

V iOS od iOS 13 systém vypíná úlohy na pozadí pro aplikace, které zneužívají čas na pozadí. Každá aplikace dostává specifické limity na základě chování uživatele. BGTaskScheduler plánuje provedení na optimální čas — například když je zařízení připojeno k Wi-Fi a nabíjí se. Aplikace, které správně používají BGTaskScheduler, získávají více času na pozadí.

V Android od Android 9 (API 28) je práce na pozadí omezena režimem Doze, který se aktivuje při nečinnosti zařízení. Aplikace v Doze nemohou vykonávat úlohy na pozadí, síť je vypnuta, JobScheduler a WorkManager odkládají úlohy do opuštění Doze. Foreground Service je jediný způsob, jak obejít Doze, ale zneužívání vede k blokování aplikace uživatelem a odebrání oprávnění.

Nejlepší postupy práce na pozadí

První pravidlo — minimalizujte spotřebu zdrojů na pozadí. Většinu úloh na pozadí lze odložit na dobu, kdy se zařízení nabíjí a je připojeno k Wi-Fi. Používejte BGTaskScheduler (iOS) a WorkManager (Android) pro plánování úloh s podmínkami. Nespouštějte těžké výpočty na pozadí — to vybíjí baterii a vede k throttlingu CPU.

Druhé pravidlo — vždy specifikujte expirationHandler pro beginBackgroundTask. Pokud aplikace nedokončí úlohu ve stanoveném čase, systém ji násilně převede do Suspended nebo ukončí. ExpirationHandler je poslední šance uložit data a správně ukončit práci. V Android používejte setForegroundAsync ve WorkManager pro převedení běžné úlohy na foreground, pokud je potřeba více času.

Třetí pravidlo — kontrolujte omezení práce na pozadí před spuštěním. V iOS použijte UIApplication.shared.backgroundTimeRemaining pro kontrolu zbývajícího času. V Android zkontrolujte ActivityManager.isBackgroundRestricted() — pokud true, aplikace nebude moci spouštět úlohy na pozadí a je třeba navrhnout uživateli odstranění omezení v nastavení. To je zvláště důležité pro aplikace s kritickými funkcemi na pozadí — budíky, kalendáře, synchronizace.

Čtvrté pravidlo — testujte úlohy na pozadí na skutečném zařízení. Simulátor a emulátor nereprodukují skutečná omezení práce na pozadí. V iOS použijte Debug → Simulate Background Fetch v Xcode. V Android — adb shell am broadcast -a android.intent.action.ACTION_BOOT_COMPLETED pro testování WorkManager po restartu. Skutečné testy na zařízení s nízkou baterií odhalí většinu problémů práce na pozadí.

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("Zbývající čas na pozadí: \(remaining) sek")

        let task = UIApplication.shared.beginBackgroundTask { [weak self] in
            print("Vypršel čas pro úlohu: \(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)
    }
}

Kód ukazuje správce úloh na pozadí, který sleduje zbývající čas a spravuje identifikátory. backgroundTimeRemaining vrací počet sekund do násilného ukončení — pokud je hodnota nekonečná, aplikace pracuje bez omezení (audio, navigace). Správce umožňuje spouštět více úloh na pozadí s různými názvy a každou správně ukončit. Tento přístup zabraňuje úniku úloh na pozadí a zaručuje, že systém neukončí aplikaci kvůli neuzavřeným úlohám.