Background: Grundlagen, App-Arbeit im Hintergrund auf iOS und Android

Background — Grundlagen des Hintergrundzustands

Background ist ein Zustand der App, in dem sie weiterhin im Betriebssystem existiert, Code ausführt und Ressourcen verbraucht, aber nicht auf dem Gerätebildschirm angezeigt wird. Der Benutzer befindet sich auf dem Startbildschirm, in einer anderen App oder der Gerätebildschirm ist gesperrt. Auf iOS folgt Background auf Inactive — die Übergangskette: Active → Inactive → Background. Auf Android signalisiert onStop den Übergang einer Activity in Background.

Beide Plattformen erlegen strenge Beschränkungen für Hintergrundarbeit auf. iOS gewährt ein begrenztes Zeitfenster (normalerweise 30 Sekunden) zur Codeausführung nach dem Eintritt in Background, danach wechselt die App in Suspended. Android ist flexibler: Ein Foreground Service mit sichtbarer Benachrichtigung kann unbegrenzt laufen, aber ein normaler Background Service ist auf wenige Minuten begrenzt. Die Hauptaufgabe des Entwicklers ist es, den Zustand korrekt zu speichern und die Fortsetzung der Arbeit über System-APIs für Hintergrundaufgaben zu planen.

Das System kann eine Hintergrund-App jederzeit bei Speichermangel beenden. Bei Beendigung gehen alle nicht gespeicherten Daten verloren. Daher ist es entscheidend, den Zustand in applicationDidEnterBackground (iOS) oder onStop (Android) zu speichern. Nach der Beendigung startet der nächste Start von Not Running mit einem Kaltstart und stellt den gespeicherten Zustand wieder her.

Background vs. Suspended

Es ist wichtig, Background von Suspended zu unterscheiden. Background — die App führt aktiv Code aus. Suspended — die App ist im Speicher, führt aber keinen Code aus — sie ist eingefroren. Auf iOS wechselt die App nach Abschluss der Hintergrundaufgaben von Background zu Suspended. Android hat kein Suspended — der Prozess existiert entweder (einschließlich Background) oder ist beendet (Not Running). Allerdings kann Android die Thread-Ausführung über LMK (Low Memory Killer) pausieren.

Background auf iOS: Swift, beginBackgroundTask und BGTaskScheduler

Auf iOS wird Background über die Delegatenmethode applicationDidEnterBackground behandelt. In dieser Methode sollte der Entwickler den Benutzerzustand speichern, Ressourcen freigeben und Hintergrundaufgaben abschließen. Um Code nach dem Eintritt in Background auszuführen, wird beginBackgroundTask(expirationHandler:) verwendet — eine API, die zusätzliche Zeit vom System anfordert (normalerweise 30 Sekunden). Wenn die Aufgabe nicht innerhalb dieser Zeit abgeschlossen wird, wird der expirationHandler aufgerufen und die App wird zwangsweise in Suspended versetzt.

Mit iOS 13 führte Apple BGTaskScheduler ein — eine moderne API zur Planung von Hintergrundaufgaben. Im Gegensatz zu beginBackgroundTask, das nur Zeit zum Beenden nach dem Hintergrundwechsel gibt, erlaubt BGTaskScheduler die Planung von Aufgaben in der Zukunft — zum Beispiel stündliche Inhaltsaktualisierungen oder das Hochladen von Analysen nachts. BGTaskScheduler ist der empfohlene Ansatz für neue Projekte, da er batterieeffizienter ist.

import UIKit
import BackgroundTasks

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    var backgroundTaskID: UIBackgroundTaskIdentifier = .invalid

    // App in den Hintergrund gewechselt — Hintergrundaufgabe starten
    func applicationDidEnterBackground(_ application: UIApplication) {
        saveAppState()
        startBackgroundTask()
    }

    private func startBackgroundTask() {
        backgroundTaskID = UIApplication.shared.beginBackgroundTask { [weak self] in
            // Zeit abgelaufen — erzwinge Beendigung
            self?.endBackgroundTask()
        }

        // Simuliere Hintergrundarbeit (Daten auf Server speichern)
        DispatchQueue.global().async { [weak self] in
            uploadAnalyticsData()
            self?.endBackgroundTask()
        }
    }

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

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

Der Code zeigt die vollständige Background-Behandlung auf iOS. applicationDidEnterBackground startet eine Hintergrundaufgabe über beginBackgroundTask mit einem Timeout und expirationHandler. Gleichzeitig wird BGTaskScheduler für regelmäßige Inhaltsaktualisierungen registriert. beginBackgroundTask wird für sofortige Beendigungsaufgaben verwendet, BGTaskScheduler für langfristige Planung. Beide APIs erfordern eine ordnungsgemäße Verwaltung der Aufgabenkennungen.

Background auf Android: Kotlin, Service, WorkManager

Auf Android wird Background über mehrere APIs verwaltet. Der traditionelle Service erlaubt die Codeausführung im Hintergrund, aber seit Android 8+ (API 26) ist der Background Service eingeschränkt: Das System beendet ihn wenige Minuten nachdem die App in den Hintergrund geht. Ein Foreground Service mit dauerhafter Benachrichtigung kann unbegrenzt laufen. WorkManager ist die empfohlene Lösung für Hintergrundaufgaben mit Ausführungsgarantie auch nach Geräteneustart.

Android unterstützt im Gegensatz zu iOS langlebige Hintergrundprozesse. Foreground Service wird für Aufgaben verwendet, die der Benutzer sehen sollte — Musikwiedergabe, Navigation, Trainingaufzeichnung. JobScheduler und WorkManager werden für Aufgaben verwendet, die aufgeschoben werden können: Datensynchronisation, Log-Hochladen, Cache-Aktualisierung. Der Hauptunterschied: Android erlaubt die Planung von Aufgaben mit Bedingungen — Wi-Fi, Laden, Geräte-Leerlauf — was Akku und Datenverkehr spart.

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

// 1. Foreground Service für langlaufende Hintergrundarbeit
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 {
            // Datensynchronisation mit Server
            syncDataToServer()
            stopForeground(STOP_FOREGROUND_REMOVE)
            stopSelf()
        }.start()
    }

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

// 2. WorkManager für verzögerte Hintergrundaufgaben
class DataSyncWorker(
    private val context: Context,
    private val params: WorkerParameters
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        return try {
            // Analysen auf Server hochladen
            uploadAnalytics()
            Result.success()
        } catch (e: Exception) {
            if (runAttemptCount < 3) Result.retry() else Result.failure()
        }
    }
}

// WorkManager Aufgabenplanung
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)
}

Der Code zeigt zwei Ansätze für Hintergrundarbeit auf Android. SyncService — ein Foreground Service mit Benachrichtigung für sofortige und langwierige Hintergrundarbeit. DataSyncWorker — WorkManager für verzögerte Aufgaben mit Bedingungen (Wi-Fi, Laden). WorkManager garantiert Ausführung auch nach Geräteneustart und unterstützt exponentielles Backoff für Wiederholungen. Foreground Service erfordert eine dauerhafte Benachrichtigung in der Statusleiste.

Einschränkungen der Hintergrundarbeit auf iOS und Android

Beide mobilen Plattformen verschärfen ständig die Regeln für Hintergrundarbeit. Auf iOS reduziert jede neue OS-Generation die Hintergrundausführungszeit und fügt neue Beschränkungen hinzu. Auf Android führt Google immer strengere Energiesparmodi (Doze, App Standby) ein. Entwickler sollten über aktuelle Einschränkungen auf dem Laufenden bleiben, damit die App nicht vorzeitig vom System beendet wird.

Auf iOS deaktiviert das System ab iOS 13 Hintergrundaufgaben für Apps, die die Hintergrundzeit missbrauchen. Jede App erhält bestimmte Grenzen basierend auf dem Benutzerverhalten. BGTaskScheduler plant die Ausführung zu optimalen Zeiten — zum Beispiel wenn das Gerät mit Wi-Fi verbunden ist und lädt. Apps, die BGTaskScheduler korrekt verwenden, erhalten mehr Hintergrundzeit.

Auf Android ist ab Android 9 (API 28) die Hintergrundarbeit durch den Doze-Modus eingeschränkt, der bei Geräte-Leerlauf aktiviert wird. Apps im Doze-Modus können keine Hintergrundaufgaben ausführen, das Netzwerk wird getrennt, JobScheduler und WorkManager verschieben Aufgaben bis zum Verlassen des Doze-Modus. Foreground Service ist der einzige Weg, Doze zu umgehen, aber Missbrauch führt zur Blockierung der App durch den Benutzer und zum Entzug der Berechtigungen.

Best Practices für Hintergrundarbeit

Erste Regel — minimieren Sie den Ressourcenverbrauch im Hintergrund. Die meisten Hintergrundaufgaben können auf Zeiten verschoben werden, in denen das Gerät lädt und mit Wi-Fi verbunden ist. Verwenden Sie BGTaskScheduler (iOS) und WorkManager (Android) zur Planung von Aufgaben mit Bedingungen. Führen Sie keine rechenintensiven Operationen im Hintergrund aus — dies entlädt den Akku und führt zur CPU-Drosselung.

Zweite Regel — geben Sie immer einen expirationHandler für beginBackgroundTask an. Wenn die App die Aufgabe nicht innerhalb der zugewiesenen Zeit abschließt, wird das System sie zwangsweise in Suspended versetzen oder beenden. Der expirationHandler ist die letzte Chance, Daten zu speichern und die Arbeit ordnungsgemäß zu beenden. Verwenden Sie auf Android setForegroundAsync in WorkManager, um eine normale Aufgabe in den Vordergrund zu konvertieren, wenn mehr Zeit benötigt wird.

Dritte Regel — überprüfen Sie die Hintergrundarbeitseinschränkungen vor dem Start. Verwenden Sie auf iOS UIApplication.shared.backgroundTimeRemaining, um die verbleibende Zeit zu prüfen. Überprüfen Sie auf Android ActivityManager.isBackgroundRestricted() — wenn true, kann die App keine Hintergrundaufgaben ausführen, und Sie sollten dem Benutzer vorschlagen, die Einschränkungen in den Einstellungen zu entfernen. Dies ist besonders wichtig für Apps mit kritischen Hintergrundfunktionen — Alarme, Kalender, Synchronisation.

Vierte Regel — testen Sie Hintergrundaufgaben auf einem echten Gerät. Simulatoren und Emulatoren reproduzieren nicht die realen Einschränkungen der Hintergrundarbeit. Verwenden Sie auf iOS Debug → Simulate Background Fetch in Xcode. Verwenden Sie auf Android adb shell am broadcast -a android.intent.action.ACTION_BOOT_COMPLETED zum Testen von WorkManager nach einem Neustart. Reale Tests auf einem Gerät mit schwachem Akku decken die meisten Probleme der Hintergrundarbeit auf.

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("Verbleibende Hintergrundzeit: \(remaining) Sek")

        let task = UIApplication.shared.beginBackgroundTask { [weak self] in
            print("Zeit für Aufgabe abgelaufen: \(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)
    }
}

Der Code zeigt einen Hintergrundaufgaben-Manager, der die verbleibende Zeit verfolgt und Kennungen verwaltet. backgroundTimeRemaining gibt die Anzahl der Sekunden vor der erzwungenen Beendigung zurück — wenn der Wert unendlich ist, läuft die App ohne Einschränkungen (Audio, Navigation). Der Manager ermöglicht das Starten mehrerer Hintergrundaufgaben mit verschiedenen Namen und das ordnungsgemäße Beenden jeder einzelnen. Dieser Ansatz verhindert Hintergrundaufgaben-Leaks und stellt sicher, dass das System die App nicht aufgrund ungeschlossener Aufgaben beendet.