Background: mga batayan, pagtatrabaho ng app sa background sa iOS at Android

Background — mga batayan ng estado ng background

Background — estado ng app kung saan ito ay patuloy na umiiral sa operating system, nag-execute ng code at kumokonsumo ng resources, ngunit hindi ipinapakita sa screen ng device. Ang user ay nasa Home Screen, sa ibang app o naka-lock ang screen ng device. Sa iOS Background ay sumusunod sa Inactive — chain ng transisyon: Active → Inactive → Background. Sa Android ang onStop ay nagpapahiwatig ng transisyon ng Activity sa Background.

Parehong platform nagpapataw ng mahigpit na limitasyon sa pagtatrabaho sa background. Ang iOS ay nagbibigay ng limitadong window (karaniwang 30 segundo) para mag-execute ng code pagkatapos pumunta sa Background, pagkatapos nito ang app ay ililipat sa Suspended. Ang Android ay mas flexible: ang Foreground Service na may visible notification ay maaaring gumana nang walang limitasyon, ngunit ang ordinaryong Background Service ay limitado sa ilang minuto. Ang pangunahing gawain ng developer — wastong mag-save ng estado at magplano ng pagpapatuloy ng trabaho sa pamamagitan ng system API ng mga gawain sa background.

Ang system ay maaaring mag-terminate ng background app anumang oras kapag kulang ang memory. Sa pag-terminate, lahat ng hindi na-save na data ay mawawala. Kaya naman kritikal na mag-save ng estado sa applicationDidEnterBackground (iOS) o onStop (Android). Pagkatapos ng termination, sa susunod na paglunsad ang app ay magsisimula mula sa Not Running na may cold start at ibabalik ang na-save na estado.

Background vs Suspended

Mahalagang pag-ibahin ang Background at Suspended. Background — ang app ay aktibong nag-e-execute ng code. Suspended — ang app ay nasa memory ngunit hindi nag-e-execute ng code — ito ay naka-freeze. Sa iOS ang app ay pumupunta mula Background papuntang Suspended pagkatapos matapos ang mga gawain sa background. Sa Android walang Suspended — ang process ay either umiiral (kasama ang background) o na-terminate (Not Running). Gayunpaman, maaaring i-pause ng Android ang pag-execute ng threads sa pamamagitan ng LMK (Low Memory Killer).

Background sa iOS: Swift, beginBackgroundTask at BGTaskScheduler

Sa iOS ang Background ay pinoproseso sa pamamagitan ng delegate method na applicationDidEnterBackground. Sa method na ito dapat i-save ng developer ang estado ng user, mag-release ng resources at tapusin ang mga gawain sa background. Para mag-execute ng code pagkatapos pumunta sa Background, ginagamit ang beginBackgroundTask(expirationHandler:) — API na humihingi ng karagdagang oras (karaniwang 30 segundo) sa system. Kung hindi matapos ang gawain sa oras na ito, tatawagin ang expirationHandler at ang app ay sapilitang ililipat sa Suspended.

Mula noong iOS 13, ipinakilala ng Apple ang BGTaskScheduler — modernong API para sa pag-iskedyul ng mga gawain sa background. Hindi tulad ng beginBackgroundTask na nagbibigay lamang ng oras para tapusin pagkatapos pumunta sa background, ang BGTaskScheduler ay nagpapahintulot sa pag-iskedyul ng pag-execute ng mga gawain sa hinaharap — halimbawa, pag-update ng content isang beses bawat oras o pag-upload ng analytics sa gabi. Ang BGTaskScheduler ay ang inirerekomendang diskarte para sa mga bagong proyekto dahil mas mahusay ito para sa baterya.

import UIKit
import BackgroundTasks

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    var backgroundTaskID: UIBackgroundTaskIdentifier = .invalid

    // Ang app ay pumunta sa background — nagsisimula ng background task
    func applicationDidEnterBackground(_ application: UIApplication) {
        saveAppState()
        startBackgroundTask()
    }

    private func startBackgroundTask() {
        backgroundTaskID = UIApplication.shared.beginBackgroundTask { [weak self] in
            // Naubos ang oras — sapilitang tinatapos
            self?.endBackgroundTask()
        }

        // Sinusubukan ang pagtatrabaho sa background (pag-save ng data sa server)
        DispatchQueue.global().async { [weak self] in
            uploadAnalyticsData()
            self?.endBackgroundTask()
        }
    }

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

    // Pagrehistro ng 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)
        }
    }
}

Ipinapakita ng code ang kumpletong pagproseso ng Background sa iOS. applicationDidEnterBackground ay nag-start ng background task sa pamamagitan ng beginBackgroundTask na may timeout at expirationHandler. Kaayon, ang BGTaskScheduler ay nirehistro para sa periodic content update. Ang beginBackgroundTask ay ginagamit para sa agarang pagtatapos ng trabaho, ang BGTaskScheduler — para sa pangmatagalang pagpaplano. Parehong API ay nangangailangan ng tamang pamamahala ng mga identifier ng gawain.

Background sa Android: Kotlin, Service, WorkManager

Sa Android ang Background ay pinamamahalaan sa pamamagitan ng ilang API. Ang tradisyonal na Service ay nagpapahintulot sa pag-execute ng code sa background, ngunit mula noong Android 8+ (API 26) ang Background Service ay limitado: tinatapos ito ng system ilang minuto pagkatapos pumunta ang app sa background. Ang Foreground Service na may permanenteng notification ay maaaring gumana nang walang limitasyon. WorkManager — ang inirerekomendang solusyon para sa mga gawain sa background na may garantiya ng pag-execute kahit na matapos i-restart ang device.

Ang Android, hindi tulad ng iOS, ay sumusuporta sa mga pangmatagalang proseso sa background. Ang Foreground Service ay ginagamit para sa mga gawain na dapat makita ng user — pag-play ng musika, navigation, pag-record ng ehersisyo. Ang JobScheduler at WorkManager — para sa mga gawain na maaaring ipagpaliban: pag-sync ng data, pag-upload ng logs, pag-update ng cache. Ang pangunahing pagkakaiba: Pinapayagan ng Android ang pag-iskedyul ng mga gawain na may kondisyon — Wi-Fi, nagcha-charge, hindi aktibo ang device, na nakakatipid ng baterya at traffic.

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

// 1. Foreground Service para sa mahabang pagtatrabaho sa background
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 {
            // Pag-sync ng data sa server
            syncDataToServer()
            stopForeground(STOP_FOREGROUND_REMOVE)
            stopSelf()
        }.start()
    }

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

// 2. WorkManager para sa mga ipinagpalibang gawain sa background
class DataSyncWorker(
    private val context: Context,
    private val params: WorkerParameters
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        return try {
            // Pag-upload ng analytics sa server
            uploadAnalytics()
            Result.success()
        } catch (e: Exception) {
            if (runAttemptCount < 3) Result.retry() else Result.failure()
        }
    }
}

// Pag-iskedyul ng WorkManager task
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)
}

Ipinapakita ng code ang dalawang diskarte sa pagtatrabaho sa background sa Android. SyncService — Foreground Service na may notification para sa agarang at mahabang pagtatrabaho sa background. DataSyncWorker — WorkManager para sa mga ipinagpalibang gawain na may kondisyon (Wi-Fi, nagcha-charge). Ginagarantiya ng WorkManager ang pag-execute kahit na matapos i-restart ang device at sumusuporta sa exponential backoff para sa mga pagsubok muli. Ang Foreground Service ay nangangailangan ng permanenteng notification sa status bar.

Mga limitasyon ng pagtatrabaho sa background sa iOS at Android

Parehong mobile platform ay patuloy na nagpapatigas ng mga patakaran sa pagtatrabaho sa background. Sa iOS bawat bagong henerasyon ng OS ay nagpapababa ng oras ng pagtatrabaho sa background at nagdadagdag ng mga bagong limitasyon. Sa Android, ipinakikilala ng Google ang lalong mahigpit na mga mode ng pagtitipid ng enerhiya (Doze, App Standby). Ang developer ay dapat may kaalaman sa kasalukuyang mga limitasyon upang ang app ay hindi ma-terminate nang maaga ng system.

Sa iOS simula noong iOS 13, ang system ay nagdi-disable ng mga gawain sa background para sa mga app na nag-aabuso ng oras sa background. Bawat app ay nakakatanggap ng tiyak na limitasyon batay sa pag-uugali ng user. BGTaskScheduler ay nag-iiskedyul ng pag-execute sa pinakamainam na oras — halimbawa, kapag ang device ay konektado sa Wi-Fi at nagcha-charge. Ang mga app na wastong gumagamit ng BGTaskScheduler ay nakakakuha ng mas maraming oras sa background.

Sa Android simula noong Android 9 (API 28) ang pagtatrabaho sa background ay limitado ng Doze mode, na naa-activate kapag hindi aktibo ang device. Ang mga app sa Doze ay hindi maaaring mag-execute ng mga gawain sa background, naka-off ang network, ang JobScheduler at WorkManager ay nagpapaliban ng mga gawain hanggang sa lumabas mula sa Doze. Ang Foreground Service ay ang tanging paraan upang lampasan ang Doze, ngunit ang pag-abuso ay humahantong sa pag-block ng app ng user at pagtanggal ng mga pahintulot.

Pinakamahusay na kasanayan sa pagtatrabaho sa background

Unang tuntunin — bawasan ang pagkonsumo ng resources sa background. Karamihan sa mga gawain sa background ay maaaring ipagpaliban hanggang sa ang device ay nagcha-charge at konektado sa Wi-Fi. Gamitin ang BGTaskScheduler (iOS) at WorkManager (Android) para sa pag-iskedyul ng mga gawain na may kondisyon. Huwag magpatakbo ng mabibigat na computation sa background — ito ay nagdidiskarga ng baterya at humahantong sa CPU throttling.

Ikalawang tuntunin — palaging tukuyin ang expirationHandler para sa beginBackgroundTask. Kung hindi matapos ng app ang gawain sa itinakdang oras, sapilitan itong ililipat ng system sa Suspended o iti-terminate. Ang expirationHandler ay ang huling pagkakataon upang mag-save ng data at tapusin ang trabaho nang wasto. Sa Android gamitin ang setForegroundAsync sa WorkManager upang i-convert ang ordinaryong gawain sa foreground kung kinakailangan ng mas maraming oras.

Ikatlong tuntunin — suriin ang mga limitasyon ng pagtatrabaho sa background bago magsimula. Sa iOS gamitin ang UIApplication.shared.backgroundTimeRemaining upang suriin ang natitirang oras. Sa Android suriin ang ActivityManager.isBackgroundRestricted() — kung true, ang app ay hindi makakapagpatakbo ng mga gawain sa background at kailangang imungkahi sa user na alisin ang mga limitasyon sa mga setting. Ito ay lalong mahalaga para sa mga app na may kritikal na function sa background — alarm, kalendaryo, pag-sync.

Ikaapat na tuntunin — subukan ang mga gawain sa background sa isang tunay na device. Ang simulator at emulator ay hindi nagre-reproduce ng tunay na limitasyon ng pagtatrabaho sa background. Sa iOS gamitin ang Debug → Simulate Background Fetch sa Xcode. Sa Android — adb shell am broadcast -a android.intent.action.ACTION_BOOT_COMPLETED para subukan ang WorkManager pagkatapos ng restart. Ang tunay na pagsubok sa device na may mababang baterya ay nagpapakita ng karamihan sa mga problema ng pagtatrabaho sa background.

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("Natitirang oras sa background: \(remaining) seg")

        let task = UIApplication.shared.beginBackgroundTask { [weak self] in
            print("Naubos ang oras para sa gawain: \(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)
    }
}

Ipinapakita ng code ang isang manager ng mga gawain sa background na sumusubaybay sa natitirang oras at namamahala sa mga identifier. backgroundTimeRemaining ay nagbabalik ng bilang ng mga segundo hanggang sa sapilitang pag-terminate — kung ang halaga ay walang hanggan, ang app ay gumagana nang walang limitasyon (audio, navigation). Ang manager ay nagpapahintulot sa pagpapatakbo ng maraming gawain sa background na may iba't ibang pangalan at wastong pagtatapos ng bawat isa. Ang diskarteng ito ay pumipigil sa pagtagas ng mga gawain sa background at ginagarantiya na ang system ay hindi magti-terminate ng app dahil sa mga hindi saradong gawain.