Inactive — der Übergangszustand zwischen Active und Background

Inactive — das Wesen des Übergangszustands

Inactive ist ein Zwischenzustand im Lebenszyklus der mobilen App, der während des Übergangs zwischen Active und Background auftritt. In diesem Zustand befindet sich die App noch im Vordergrund und ist für den Benutzer sichtbar, empfängt aber keine Berührungsereignisse, Tastendrücke oder andere UI-Ereignisse. Das System blockiert die Ereignisübermittlung an die App, aber die UI bleibt auf dem Bildschirm und wird nicht minimiert.

Die Natur von Inactive ist temporär. Dieser Zustand dauert genau so lange wie die Systemunterbrechung: von 0,1 Sekunden beim schnellen Schließen des Control Centers bis zu mehreren Sekunden bei einem eingehenden Anruf mit Anrufbildschirm. Nach dem Ende der Unterbrechung kehrt die App entweder zu Active zurück oder wechselt zu Background, wenn der Benutzer zu einer anderen App gewechselt hat. Inactive ist der einzige Zustand, der in beide Richtungen wechseln kann: zurück zu Active oder weiter zu Background.

Auf iOS wird Inactive automatisch vom System verwaltet. Der Entwickler kann die Zeit in Inactive weder verlängern noch verkürzen — sie wird vollständig von UIApplication kontrolliert. Das Einzige, was der Entwickler tun kann, ist den Übergang zu Inactive über applicationWillResignActive und die Rückkehr über applicationDidBecomeActive korrekt zu behandeln. Auf Android ist das Äquivalent onPause, obwohl die Semantik unterschiedlich ist: onPause wird auch aufgerufen, wenn eine Activity teilweise von einer anderen Komponente überdeckt wird.

Vergleich von Inactive auf iOS und Android

Auf iOS ist Inactive ein separater Zustand des Anwendungslebenszyklus (einer von fünf: Not Running, Active, Inactive, Background, Suspended). Auf Android gibt es kein direktes Äquivalent — onPause signalisiert, dass die Activity den Eingabefokus verliert, aber sichtbar bleiben kann (zum Beispiel beim Öffnen eines Dialogs). Der Hauptunterschied: iOS Inactive ist ein app-weiter Zustand, während Android onPause ein pro-Activity-Zustand ist. Im Android-Multi-Window kann eine Activity in onPause (ohne Fokus) sein, während eine andere in onResume (mit Fokus) ist.

Wann Inactive auftritt

Inactive tritt auf iOS in mehreren streng definierten Szenarien auf. Der Benutzer öffnet das Control Center (Wischen von der oberen rechten Ecke nach unten auf iPhone X+ oder nach oben auf älteren Modellen). Der Benutzer öffnet das Notification Center (Wischen von der oberen linken Ecke nach unten). Ein eingehender Anruf kommt — das System zeigt den Anrufbildschirm über der App an. Eine Systemberechtigung wird angefordert — Geolokalisierung, Mikrofon, Kamera, Kontakte. Auf iPad wird Slide Over oder Split View gestartet — die aktive Szene wird Inactive.

Auf Android tritt onPause (das Äquivalent von Inactive) in einem noch breiteren Spektrum von Situationen auf. Öffnen eines Dialogs (AlertDialog, DialogFragment). Teilweise Überlagerung einer Activity durch eine andere Activity (zum Beispiel eine transparente Activity zur Authentifizierung). Bildschirmdrehung (die Activity wird neu erstellt, Reihenfolge: onPause → onStop → onDestroy → onCreate → onStart → onResume). Multi-Window-Modus — das inaktive Fenster erhält onPause. Jedes dieser Ereignisse erfordert das Aussetzen ressourcenintensiver Operationen, um Akku und Leistung zu schonen.

import UIKit

extension Notification.Name {
    static let systemInterruptionBegan = Notification.Name("systemInterruptionBegan")
    static let systemInterruptionEnded = Notification.Name("systemInterruptionEnded")
}

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func applicationWillResignActive(_ application: UIApplication) {
        // App wechselt zu Inactive — Systemunterbrechung
        print("Unterbrechung: Control Center, Anruf oder Systemalert")

        // Aussetzen zeitkritischer Operationen
        pauseVideoPlayback()
        stopContinuousDataCollection()
        hideSensitiveInformation()

        // Benachrichtigung der Komponenten
        NotificationCenter.default.post(name: .systemInterruptionBegan, object: nil)
    }

    // Rückkehr von Inactive zu Active
    func applicationDidBecomeActive(_ application: UIApplication) {
        resumeVideoPlayback()
        restartDataCollection()
        NotificationCenter.default.post(name: .systemInterruptionEnded, object: nil)
    }

    private func pauseVideoPlayback() {
        // Video pausieren, damit Audio sich nicht überlagert
    }

    private func hideSensitiveInformation() {
        // Ausblenden sensibler Daten bei Bildschirmfoto
        // Control Center/App Switcher machen einen Screenshot der UI
    }
}

Der Code zeigt die Behandlung von Inactive in UIKit. applicationWillResignActive pausiert Video, stoppt die Datensammlung und verbirgt vertrauliche Informationen. Dies ist wichtig, denn wenn Control Center oder App Switcher geöffnet werden, macht das System einen Screenshot der aktuellen UI — der Benutzer könnte vertrauliche Daten in der Vorschau sehen. NotificationCenter ermöglicht es App-Komponenten, Unterbrechungsereignisse zu abonnieren.

Inactive auf iOS: Swift und UIKit

Auf iOS wird Inactive von einem Methodenpaar behandelt: applicationWillResignActive (Übergang zu Inactive) und applicationDidBecomeActive (Rückkehr von Inactive). Diese Methoden sind Teil von UIApplicationDelegate und werden bei jedem Übergang durch Inactive aufgerufen. Seit iOS 13 und UISceneDelegate wurden sceneWillResignActive und sceneDidBecomeActive für Multi-Window-Szenarien hinzugefügt.

SceneDelegate und Multi-Window-Inactive

Auf iPad mit iOS 13+ kann eine App mehrere Szenen (Fenster) haben. Jede Szene hat ihren eigenen Lebenszyklus. Eine Szene kann Inactive werden (der Benutzer hat zu einer anderen Szene gewechselt), während eine andere Active bleibt. Dies ist ein wichtiger Unterschied zum iPhone, wo Inactive ein globaler Zustand für die gesamte App ist. Bei der Entwicklung für iPad muss Inactive für jede Szene separat behandelt werden.

import UIKit

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    // Szene wird inaktiv
    func sceneWillResignActive(_ scene: UIScene) {
        // Auf iPad verliert diese Szene den Fokus, aber andere können aktiv sein
        print("Szene verliert Aktivität")

        // Aussetzen der Aufgaben dieser Szene
        pauseSceneSpecificOperations()
    }

    // Szene wird aktiv
    func sceneDidBecomeActive(_ scene: UIScene) {
        print("Szene wurde aktiv")
        resumeSceneSpecificOperations()
    }

    private func pauseSceneSpecificOperations() {
        // Aussetzen von für diese Szene spezifischen Operationen
    }

    private func resumeSceneSpecificOperations() {
        // Wiederaufnahme von Operationen bei Rückkehr des Fokus
    }
}

// AppDelegate bleibt Einstiegspunkt, delegiert an Szenen
@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(
        _ application: UIApplication,
        configurationForConnecting connectingSceneSession: UISceneSession,
        options: UIScene.ConnectionOptions
    ) -> UISceneConfiguration {
        return UISceneConfiguration(
            name: "Default Configuration",
            sessionRole: connectingSceneSession.role
        )
    }
}

Der Code zeigt einen SceneDelegate zur Behandlung von Inactive auf Szenenebene. sceneWillResignActive wird aufgerufen, wenn ein bestimmtes Fenster den Fokus verliert — dies kann beim Wechsel zwischen Fenstern auf iPad passieren. AppDelegate konfiguriert UISceneConfiguration zur Unterstützung von Multi-Window. Jede Szene hat einen unabhängigen Zustand und der Entwickler muss sie separat behandeln.

Inactive auf Android: onPause und Sichtbarkeit

Auf Android ist das direkte Äquivalent von iOS Inactive die onPause()-Methode des Activity-Lebenszyklus. Sie wird aufgerufen, wenn die Activity den Eingabefokus verliert, aber sichtbar bleiben kann. Typische Szenarien: Öffnen eines Dialogs, Starten einer anderen Activity in derselben App, eingehender Anruf, Drücken der Home- oder Recents-Taste. In onPause sollte der Entwickler ressourcenintensive Operationen — Animationen, Videowiedergabe, Kamerarbeit — aussetzen.

Ein wichtiger Unterschied bei Android ist, dass onPause immer vor onStop kommt, aber nicht umgekehrt. Eine Activity kann onPause ohne onStop erhalten (zum Beispiel beim Öffnen einer transparenten Activity). Außerdem kann onPause während der Lebensdauer einer Activity mehrmals aufgerufen werden — bei jedem Fokuswechsel. Platzieren Sie keine einmalige Logik in onPause — verwenden Sie onStop für finale Operationen und onPause nur zum Aussetzen interaktiver Aktionen.

class VideoPlayerActivity : AppCompatActivity() {

    private var exoPlayer: ExoPlayer? = null
    private var currentPosition: Long = 0L

    override fun onPause() {
        super.onPause()
        // App verliert Fokus — Video pausieren
        exoPlayer?.let { player ->
            if (player.isPlaying) {
                currentPosition = player.currentPosition
                player.pause()
            }
        }
        // Sensible Daten ausblenden (GDPR/Banking-Bildschirme)
        if (window.decorView.systemUiVisibility and
            View.SYSTEM_UI_FLAG_SECURE == 0
        ) {
            hideSensitiveOverlay()
        }
    }

    override fun onResume() {
        super.onResume()
        // Fokus kehrt zurück — Wiedergabe fortsetzen
        exoPlayer?.seekTo(currentPosition)
        exoPlayer?.play()
        showSensitiveOverlay()
    }

    private fun hideSensitiveOverlay() {
        // Schwarzen Bildschirm über Finanzdaten legen
    }
}

Der Code zeigt die korrekte Behandlung von onPause für einen Videoplayer. ExoPlayer wird pausiert, wenn der Fokus verloren geht, und die Wiedergabeposition wird gespeichert. Bei der Rückkehr zu onResume nimmt der Player die Wiedergabe von der gespeicherten Position wieder auf. Zusätzlich wird ein Muster zum Ausblenden sensibler Daten gezeigt — wichtig für Finanz- und Medizin-Apps, die beim Wechseln Schutz vor Screenshots benötigen.

Bewährte Verfahren zur Behandlung von Inactive

Erste Regel — vertrauliche Daten beim Übergang zu Inactive ausblenden. Wenn der Benutzer das Control Center oder den App Switcher öffnet, macht iOS einen Screenshot des aktuellen Bildschirms. Auf Android zeigt das System ähnlich eine Vorschau der letzten Activity in Recents an. Verwenden Sie UIApplication.shouldSnapshotSecureApp (iOS 16+) oder FLAG_SECURE (Android) zum Schutz vertraulicher Bildschirme.

Zweite Regel — Animationen und Medien pausieren. Inactive ist keine gute Zeit zum Abspielen von Videos oder Animationen, da der Benutzer sie nicht sehen kann. Darüber hinaus kann die Wiedergabe im Hintergrund dazu führen, dass Audio mit Systemtönen (Klingelton, Benachrichtigung) überlagert wird. Stoppen Sie AVPlayer, ExoPlayer und UIView.animate beim Wechsel zu Inactive und setzen Sie sie bei der Rückkehr zu Active fort.

Dritte Regel — Dateneingabe blockieren. Wenn die App Eingabeformulare oder Entwürfe enthält, sperren Sie die Tastatur und Eingabefelder beim Wechsel zu Inactive. Dies verhindert versehentliche Eingaben bei der Rückkehr und schützt vor Datenabfang durch System-Overlays. Auf iOS den First Responder beenden (view.endEditing(true)), auf Android — Fokus löschen (currentFocus?.clearFocus()).

Vierte Regel — führen Sie keine langen Operationen in applicationWillResignActive oder onPause durch. Diese Methoden sollten in Sekundenbruchteilen abgeschlossen sein. Wenn Sie eine große Datenmenge speichern müssen, beginnen Sie das Speichern in einem Hintergrundthread und schließen Sie es in applicationDidEnterBackground oder onStop ab. iOS gibt 5 Sekunden für die Ausführung von applicationWillResignActive, danach kann das System die App zwangsweise beenden.

import UIKit

final class SecureOverlayManager {
    private var blurView: UIVisualEffectView?

    func showBlurOverlay() {
        guard let window = UIApplication.shared.keyWindow,
              blurView == nil
        else { return }

        let blur = UIVisualEffectView(effect: UIBlurEffect(style: .dark))
        blur.frame = window.bounds
        blur.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        window.addSubview(blur)
        blurView = blur
    }

    func removeBlurOverlay() {
        blurView?.removeFromSuperview()
        blurView = nil
    }
}

// Verwendung in AppDelegate
func applicationWillResignActive(_ application: UIApplication) {
    SecureOverlayManager().showBlurOverlay()
}

func applicationDidBecomeActive(_ application: UIApplication) {
    SecureOverlayManager().removeBlurOverlay()
}

Der Code zeigt die Implementierung eines sicheren Overlays zum Datenschutz beim Übergang zu Inactive. Eine UIVisualEffectView mit Unschärfeeffekt wird beim Wechsel zu Inactive über die gesamte UI gelegt und bei der Rückkehr zu Active entfernt. Dies stellt sicher, dass vertrauliche Daten in App Switcher- und Control Center-Screenshots nicht sichtbar sind. Ähnlich können Sie UIImageView mit einem Logo für ein gebrandetes Overlay verwenden.