Background: βασικές έννοιες, λειτουργία εφαρμογής στο παρασκήνιο iOS και Android

Background — βασικές έννοιες της κατάστασης παρασκηνίου

Background — κατάσταση της εφαρμογής στην οποία συνεχίζει να υπάρχει στο λειτουργικό σύστημα, να εκτελεί κώδικα και να καταναλώνει πόρους, αλλά δεν εμφανίζεται στην οθόνη της συσκευής. Ο χρήστης βρίσκεται στην Αρχική οθόνη, σε άλλη εφαρμογή ή η οθόνη της συσκευής είναι κλειδωμένη. Σε iOS το Background ακολουθεί το Inactive — αλυσίδα μετάβασης: Active → Inactive → Background. Σε Android το onStop σηματοδοτεί τη μετάβαση του Activity σε Background.

Και οι δύο πλατφόρμες επιβάλλουν αυστηρούς περιορισμούς στην εργασία παρασκηνίου. Το iOS παρέχει ένα περιορισμένο παράθυρο (συνήθως 30 δευτερόλεπτα) για εκτέλεση κώδικα μετά τη μετάβαση σε Background, μετά το οποίο η εφαρμογή μεταφέρεται σε Suspended. Το Android είναι πιο ευέλικτο: το Foreground Service με ορατή ειδοποίηση μπορεί να λειτουργεί απεριόριστα, αλλά το κανονικό Background Service περιορίζεται σε λίγα λεπτά. Το βασικό καθήκον του προγραμματιστή — να αποθηκεύσει σωστά την κατάσταση και να προγραμματίσει τη συνέχιση της εργασίας μέσω συστημικών API εργασιών παρασκηνίου.

Το σύστημα μπορεί να τερματίσει την εφαρμογή παρασκηνίου ανά πάσα στιγμή σε περίπτωση έλλειψης μνήμης. Κατά τον τερματισμό, όλα τα μη αποθηκευμένα δεδομένα χάνονται. Γι'αυτό είναι κρίσιμο να αποθηκεύετε την κατάσταση στο applicationDidEnterBackground (iOS) ή onStop (Android). Μετά τον τερματισμό, στην επόμενη εκκίνηση η εφαρμογή ξεκινά από το Not Running με ψυχρή εκκίνηση και επαναφέρει την αποθηκευμένη κατάσταση.

Background vs Suspended

Είναι σημαντικό να διακρίνετε το Background από το Suspended. Background — η εφαρμογή εκτελεί ενεργά κώδικα. Suspended — η εφαρμογή βρίσκεται στη μνήμη αλλά δεν εκτελεί κώδικα — είναι παγωμένη. Σε iOS η εφαρμογή μεταβαίνει από Background σε Suspended μετά την ολοκλήρωση των εργασιών παρασκηνίου. Σε Android δεν υπάρχει Suspended — η διεργασία είτε υπάρχει (συμπεριλαμβανομένου του παρασκηνίου) είτε έχει τερματιστεί (Not Running). Ωστόσο, το Android μπορεί να αναστείλει την εκτέλεση νημάτων μέσω LMK (Low Memory Killer).

Background σε iOS: Swift, beginBackgroundTask και BGTaskScheduler

Σε iOS το Background υποβάλλεται σε επεξεργασία μέσω της μεθόδου αντιπροσώπου applicationDidEnterBackground. Σε αυτήν τη μέθοδο, ο προγραμματιστής πρέπει να αποθηκεύσει την κατάσταση του χρήστη, να ελευθερώσει πόρους και να ολοκληρώσει τις εργασίες παρασκηνίου. Για την εκτέλεση κώδικα μετά τη μετάβαση σε Background χρησιμοποιείται το beginBackgroundTask(expirationHandler:) — ένα API που ζητά από το σύστημα επιπλέον χρόνο (συνήθως 30 δευτερόλεπτα). Εάν η εργασία δεν ολοκληρωθεί σε αυτό το χρονικό διάστημα, καλείται το expirationHandler και η εφαρμογή μεταφέρεται υποχρεωτικά σε Suspended.

Από το iOS 13, η Apple εισήγαγε το BGTaskScheduler — ένα σύγχρονο API για τον προγραμματισμό εργασιών παρασκηνίου. Σε αντίθεση με το beginBackgroundTask, το οποίο δίνει χρόνο μόνο για ολοκλήρωση μετά τη μετάβαση στο παρασκήνιο, το BGTaskScheduler επιτρέπει τον προγραμματισμό εκτέλεσης εργασιών στο μέλλον — για παράδειγμα, ενημέρωση περιεχομένου μία φορά την ώρα ή μεταφόρτωση αναλυτικών στοιχείων τη νύχτα. Το BGTaskScheduler είναι η συνιστώμενη προσέγγιση για νέα έργα, καθώς είναι πιο αποδοτικό όσον αφορά την μπαταρία.

import UIKit
import BackgroundTasks

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    var backgroundTaskID: UIBackgroundTaskIdentifier = .invalid

    // Η εφαρμογή πήγε στο παρασκήνιο — ξεκινάμε εργασία παρασκηνίου
    func applicationDidEnterBackground(_ application: UIApplication) {
        saveAppState()
        startBackgroundTask()
    }

    private func startBackgroundTask() {
        backgroundTaskID = UIApplication.shared.beginBackgroundTask { [weak self] in
            // Ο χρόνος τελείωσε — υποχρεωτικός τερματισμός
            self?.endBackgroundTask()
        }

        // Προσομοιώνουμε εργασία παρασκηνίου (αποθήκευση δεδομένων στον διακομιστή)
        DispatchQueue.global().async { [weak self] in
            uploadAnalyticsData()
            self?.endBackgroundTask()
        }
    }

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

    // Καταχώρηση 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)
        }
    }
}

Ο κώδικας δείχνει την πλήρη επεξεργασία του Background σε iOS. applicationDidEnterBackground ξεκινά μια εργασία παρασκηνίου μέσω beginBackgroundTask με χρονικό όριο και expirationHandler. Παράλληλα, το BGTaskScheduler καταχωρείται για περιοδική ενημέρωση περιεχομένου. Το beginBackgroundTask χρησιμοποιείται για άμεση ολοκλήρωση της εργασίας, το BGTaskScheduler — για μακροπρόθεσμο προγραμματισμό. Και τα δύο API απαιτούν σωστή διαχείριση των αναγνωριστικών εργασιών.

Background σε Android: Kotlin, Service, WorkManager

Σε Android το Background διαχειρίζεται μέσω πολλών API. Το παραδοσιακό Service επιτρέπει την εκτέλεση κώδικα στο παρασκήνιο, αλλά από Android 8+ (API 26) το Background Service είναι περιορισμένο: το σύστημα το τερματίζει λίγα λεπτά μετά τη μετάβαση της εφαρμογής στο παρασκήνιο. Το Foreground Service με μόνιμη ειδοποίηση μπορεί να λειτουργεί απεριόριστα. WorkManager — η συνιστώμενη λύση για εργασίες παρασκηνίου με εγγύηση εκτέλεσης ακόμη και μετά από επανεκκίνηση της συσκευής.

Το Android, σε αντίθεση με το iOS, υποστηρίζει μακροχρόνιες διεργασίες παρασκηνίου. Το Foreground Service χρησιμοποιείται για εργασίες που ο χρήστης πρέπει να βλέπει — αναπαραγωγή μουσικής, πλοήγηση, καταγραφή προπόνησης. Το JobScheduler και WorkManager — για εργασίες που μπορούν να αναβληθούν: συγχρονισμός δεδομένων, μεταφόρτωση αρχείων καταγραφής, ενημέρωση προσωρινής μνήμης. Η βασική διαφορά: το Android επιτρέπει τον προγραμματισμό εργασιών με συνθήκες — Wi-Fi, φόρτιση, αδράνεια συσκευής, γεγονός που εξοικονομεί μπαταρία και κίνηση δεδομένων.

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

// 1. 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 {
            // Συγχρονισμός δεδομένων με τον διακομιστή
            syncDataToServer()
            stopForeground(STOP_FOREGROUND_REMOVE)
            stopSelf()
        }.start()
    }

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

// 2. WorkManager για αναβλημένες εργασίες παρασκηνίου
class DataSyncWorker(
    private val context: Context,
    private val params: WorkerParameters
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        return try {
            // Μεταφόρτωση αναλυτικών στον διακομιστή
            uploadAnalytics()
            Result.success()
        } catch (e: Exception) {
            if (runAttemptCount < 3) Result.retry() else Result.failure()
        }
    }
}

// Προγραμματισμός εργασίας 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)
}

Ο κώδικας δείχνει δύο προσεγγίσεις για εργασία παρασκηνίου σε Android. SyncService — Foreground Service με ειδοποίηση για άμεση και μακρά εργασία παρασκηνίου. DataSyncWorker — WorkManager για αναβλημένες εργασίες με συνθήκες (Wi-Fi, φόρτιση). Το WorkManager εγγυάται την εκτέλεση ακόμη και μετά από επανεκκίνηση της συσκευής και υποστηρίζει exponential backoff για επαναλαμβανόμενες προσπάθειες. Το Foreground Service απαιτεί μόνιμη ειδοποίηση στη γραμμή κατάστασης.

Περιορισμοί εργασίας παρασκηνίου σε iOS και Android

Και οι δύο κινητές πλατφόρμες αυστηροποιούν συνεχώς τους κανόνες εργασίας παρασκηνίου. Σε iOS κάθε νέα γενιά λειτουργικού συστήματος μειώνει τον χρόνο εργασίας παρασκηνίου και προσθέτει νέους περιορισμούς. Σε Android η Google εισάγει ολοένα και πιο αυστηρές λειτουργίες εξοικονόμησης ενέργειας (Doze, App Standby). Ο προγραμματιστής πρέπει να γνωρίζει τους τρέχοντες περιορισμούς ώστε η εφαρμογή να μην τερματίζεται πρόωρα από το σύστημα.

Σε iOS από το iOS 13, το σύστημα απενεργοποιεί τις εργασίες παρασκηνίου για εφαρμογές που κάνουν κατάχρηση του χρόνου παρασκηνίου. Κάθε εφαρμογή λαμβάνει συγκεκριμένα όρια με βάση τη συμπεριφορά του χρήστη. BGTaskScheduler προγραμματίζει την εκτέλεση στον βέλτιστο χρόνο — για παράδειγμα, όταν η συσκευή είναι συνδεδεμένη σε Wi-Fi και φορτίζεται. Οι εφαρμογές που χρησιμοποιούν σωστά το BGTaskScheduler λαμβάνουν περισσότερο χρόνο παρασκηνίου.

Σε Android από το Android 9 (API 28) η εργασία παρασκηνίου περιορίζεται από τη λειτουργία Doze, η οποία ενεργοποιείται όταν η συσκευή είναι αδρανής. Οι εφαρμογές σε Doze δεν μπορούν να εκτελούν εργασίες παρασκηνίου, το δίκτυο απενεργοποιείται, το JobScheduler και WorkManager αναβάλλουν εργασίες έως ότου εξέλθουν από το Doze. Το Foreground Service είναι ο μόνος τρόπος παράκαμψης του Doze, αλλά η κατάχρηση οδηγεί σε αποκλεισμό της εφαρμογής από τον χρήστη και αφαίρεση αδειών.

Βέλτιστες πρακτικές εργασίας παρασκηνίου

Πρώτος κανόνας — ελαχιστοποιήστε την κατανάλωση πόρων στο παρασκήνιο. Οι περισσότερες εργασίες παρασκηνίου μπορούν να αναβληθούν για όταν η συσκευή φορτίζεται και είναι συνδεδεμένη σε Wi-Fi. Χρησιμοποιήστε BGTaskScheduler (iOS) και WorkManager (Android) για τον προγραμματισμό εργασιών με συνθήκες. Μην εκτελείτε βαριούς υπολογισμούς στο παρασκήνιο — αυτό εξαντλεί την μπαταρία και οδηγεί σε περιορισμό της CPU.

Δεύτερος κανόνας — πάντα να ορίζετε expirationHandler για το beginBackgroundTask. Εάν η εφαρμογή δεν ολοκληρώσει την εργασία στον καθορισμένο χρόνο, το σύστημα θα τη μεταφέρει υποχρεωτικά σε Suspended ή θα την τερματίσει. Το expirationHandler είναι η τελευταία ευκαιρία για αποθήκευση δεδομένων και σωστό τερματισμό. Σε Android χρησιμοποιήστε setForegroundAsync στο WorkManager για μετατροπή μιας συνηθισμένης εργασίας σε foreground, εάν απαιτείται περισσότερος χρόνος.

Τρίτος κανόνας — ελέγχετε τους περιορισμούς εργασίας παρασκηνίου πριν από την έναρξη. Σε iOS χρησιμοποιήστε UIApplication.shared.backgroundTimeRemaining για έλεγχο του υπολειπόμενου χρόνου. Σε Android ελέγξτε το ActivityManager.isBackgroundRestricted() — εάν είναι true, η εφαρμογή δεν θα μπορεί να εκτελεί εργασίες παρασκηνίου και πρέπει να προτείνετε στον χρήστη να αφαιρέσει τους περιορισμούς στις ρυθμίσεις. Αυτό είναι ιδιαίτερα σημαντικό για εφαρμογές με κρίσιμες λειτουργίες παρασκηνίου — ξυπνητήρια, ημερολόγια, συγχρονισμός.

Τέταρτος κανόνας — δοκιμάστε τις εργασίες παρασκηνίου σε πραγματική συσκευή. Ο προσομοιωτής και ο εξομοιωτής δεν αναπαράγουν τους πραγματικούς περιορισμούς εργασίας παρασκηνίου. Σε iOS χρησιμοποιήστε Debug → Simulate Background Fetch στο Xcode. Σε Android — adb shell am broadcast -a android.intent.action.ACTION_BOOT_COMPLETED για δοκιμή του WorkManager μετά από επανεκκίνηση. Πραγματικές δοκιμές σε συσκευή με χαμηλή μπαταρία αποκαλύπτουν τα περισσότερα προβλήματα εργασίας παρασκηνίου.

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("Υπολειπόμενος χρόνος στο παρασκήνιο: \(remaining) δευτ")

        let task = UIApplication.shared.beginBackgroundTask { [weak self] in
            print("Έληξε ο χρόνος για την εργασία: \(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)
    }
}

Ο κώδικας δείχνει έναν διαχειριστή εργασιών παρασκηνίου που παρακολουθεί τον υπολειπόμενο χρόνο και διαχειρίζεται τα αναγνωριστικά. backgroundTimeRemaining επιστρέφει τον αριθμό δευτερολέπτων έως τον υποχρεωτικό τερματισμό — εάν η τιμή είναι άπειρη, η εφαρμογή λειτουργεί χωρίς περιορισμό (ήχος, πλοήγηση). Ο διαχειριστής επιτρέπει την εκτέλεση πολλών εργασιών παρασκηνίου με διαφορετικά ονόματα και τον σωστό τερματισμό κάθε μίας. Αυτή η προσέγγιση αποτρέπει τη διαρροή εργασιών παρασκηνίου και εγγυάται ότι το σύστημα δεν θα τερματίσει την εφαρμογή λόγω μη κλειστών εργασιών.