Inactive — de essentie van de overgangstoestand tussen Active en Background

Inactive — de essentie van de overgangstoestand

Inactive — een tussentoestand van de levenscyclus van een mobiele app die optreedt bij de overgang tussen Active en Background. In deze toestand bevindt de app zich nog steeds op de voorgrond en is zichtbaar voor de gebruiker, maar ontvangt geen aanraakgebeurtenissen, toetsaanslagen of andere UI-gebeurtenissen. Het systeem blokkeert de overdracht van gebeurtenissen naar de app, maar de UI blijft op het scherm en wordt niet geminimaliseerd.

De aard van Inactive is tijdelijk. Deze toestand duurt precies zo lang als de systeemonderbreking duurt: van 0.1 seconde bij het snel sluiten van Control Center tot enkele seconden bij een inkomende oproep met een oproepscherm. Na het einde van de onderbreking keert de app terug naar Active of gaat naar Background als de gebruiker naar een andere app is overgeschakeld. Inactive is de enige toestand waaruit overgang in beide richtingen mogelijk is: terug naar Active of verder naar Background.

Op iOS wordt Inactive automatisch door het systeem beheerd. De ontwikkelaar kan de tijd in Inactive niet verlengen of verkorten — dit wordt volledig gecontroleerd door UIApplication. Het enige wat de ontwikkelaar kan doen, is het correct afhandelen van de overgang naar Inactive via applicationWillResignActive en de terugkeer via applicationDidBecomeActive. Op Android is de tegenhanger onPause, hoewel de semantiek verschilt: onPause wordt aangeroepen, zelfs bij gedeeltelijke bedekking van Activity door een andere component.

Vergelijking van Inactive op iOS en Android

Op iOS is Inactive een aparte toestand van de levenscyclus van de app (een van de vijf: Not Running, Active, Inactive, Background, Suspended). Op Android is er geen directe tegenhanger — onPause geeft aan dat Activity de invoerfocus verliest, maar zichtbaar kan blijven (bijvoorbeeld bij het openen van een dialoog). Het belangrijkste verschil: iOS Inactive is de toestand van de app als geheel, Android onPause is de toestand van een specifieke Activity. In de multi-window-modus op Android kan de ene Activity in onPause zijn (zonder focus) en de andere in onResume (met focus).

Wanneer treedt Inactive op

Inactive op iOS treedt op in een aantal strikt gedefinieerde scenario’s. De gebruiker roept Control Center op (veeg omlaag vanuit de rechterbovenhoek op iPhone X+ of veeg omhoog op oudere modellen). De gebruiker opent Notification Center (veeg omlaag vanuit de linkerbovenhoek). Er komt een inkomende oproep binnen — het systeem toont het oproepscherm boven de app. Er wordt een systeemtoestemming aangevraagd — geolocatie, microfoon, camera, contacten. Op iPad wordt Slide Over of Split View gestart — de actieve scene wordt Inactive.

Op Android treedt onPause (de tegenhanger van Inactive) op in een nog breder scala aan situaties. Het openen van een dialoogvenster (AlertDialog, DialogFragment). Gedeeltelijke bedekking van Activity door een andere Activity (bijvoorbeeld een transparante Activity voor authenticatie). Schermrotatie (Activity wordt opnieuw aangemaakt, volgorde: onPause → onStop → onDestroy → onCreate → onStart → onResume). Multi-window-modus — het inactieve venster krijgt onPause. Elk van deze gebeurtenissen vereist het onderbreken van resource-intensieve bewerkingen om batterij en prestaties te sparen.

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 gaat naar Inactive — systeemonderbreking
        print("Onderbreking: Control Center, oproep of systeemalert")

        // Onderbreken van tijdgevoelige bewerkingen
        pauseVideoPlayback()
        stopContinuousDataCollection()
        hideSensitiveInformation()

        // Melding van componenten
        NotificationCenter.default.post(name: .systemInterruptionBegan, object: nil)
    }

    // Terugkeer van Inactive naar Active
    func applicationDidBecomeActive(_ application: UIApplication) {
        resumeVideoPlayback()
        restartDataCollection()
        NotificationCenter.default.post(name: .systemInterruptionEnded, object: nil)
    }

    private func pauseVideoPlayback() {
        // Video stoppen zodat geluid niet overlapt
    }

    private func hideSensitiveInformation() {
        // Verbergen van gevoelige gegevens bij schermafbeelding
        // Control Center/App Switcher maken schermafbeelding van UI
    }
}

De code toont de afhandeling van Inactive in UIKit. applicationWillResignActive stopt de video, stopt het verzamelen van gegevens en verbergt gevoelige informatie. Dit is belangrijk omdat bij het openen van Control Center of App Switcher het systeem een schermafbeelding maakt van de huidige UI — de gebruiker kan vertrouwelijke gegevens zien in de preview. NotificationCenter stelt app-componenten in staat om te abonneren op onderbrekingsgebeurtenissen.

Inactive op iOS: Swift en UIKit

Op iOS wordt Inactive afgehandeld door een paar methoden: applicationWillResignActive (overgang naar Inactive) en applicationDidBecomeActive (terugkeer uit Inactive). Deze methoden maken deel uit van UIApplicationDelegate en worden aangeroepen voor elke overgang door Inactive. Sinds iOS 13 en UISceneDelegate zijn sceneWillResignActive en sceneDidBecomeActive toegevoegd voor multi-window-scenario’s.

SceneDelegate en multi-window Inactive

Op iPad met iOS 13+ kan een app meerdere scenes (vensters) hebben. Elke scene heeft een eigen levenscyclus. De ene scene kan Inactive worden (de gebruiker is naar een andere scene overgeschakeld), terwijl de andere Active blijft. Dit is een belangrijk verschil met de iPhone, waar Inactive een globale toestand is voor de hele app. Bij het ontwikkelen voor iPad moet Inactive voor elke scene afzonderlijk worden afgehandeld.

import UIKit

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    // Scene wordt inactief
    func sceneWillResignActive(_ scene: UIScene) {
        // Op iPad verliest deze scene focus, maar andere kunnen actief zijn
        print("Scene verliest activiteit")

        // Onderbreken van taken van deze scene
        pauseSceneSpecificOperations()
    }

    // Scene wordt actief
    func sceneDidBecomeActive(_ scene: UIScene) {
        print("Scene is actief geworden")
        resumeSceneSpecificOperations()
    }

    private func pauseSceneSpecificOperations() {
        // Onderbreken van specifieke bewerkingen voor deze scene
    }

    private func resumeSceneSpecificOperations() {
        // Hervatten van bewerkingen bij terugkeer van focus
    }
}

// AppDelegate blijft toegangspunt, delegeert aan scenes
@main
class AppDelegate: UIResponder, UIApplicationDelegate {

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

De code toont SceneDelegate voor het afhandelen van Inactive op sceneniveau. sceneWillResignActive wordt aangeroepen wanneer een specifiek venster de focus verliest — dit kan gebeuren bij het schakelen tussen vensters op iPad. AppDelegate configureert UISceneConfiguration voor ondersteuning van multi-window. Elke scene heeft een onafhankelijke toestand en de ontwikkelaar moet ze afzonderlijk afhandelen.

Inactive op Android: onPause en zichtbaarheid

Op Android is de directe tegenhanger van iOS Inactive de methode onPause() van de levenscyclus van Activity. Deze wordt aangeroepen wanneer Activity de invoerfocus verliest, maar zichtbaar kan blijven. Typische scenario’s: het openen van een dialoogvenster, het starten van een andere Activity in dezelfde app, een inkomende oproep, het indrukken van de Home- of Recents-knop. In onPause moet de ontwikkelaar resource-intensieve bewerkingen onderbreken — animaties, videoweergave, werk met de camera.

Een belangrijk verschil op Android — onPause gaat altijd vooraf aan onStop, maar niet andersom. Activity kan onPause ontvangen zonder onStop (bijvoorbeeld bij het openen van een transparante Activity). Ook kan onPause meerdere keren worden aangeroepen tijdens de levensduur van Activity — bij elke focuswijziging. Plaats geen eenmalige logica in onPause — gebruik onStop voor definitieve bewerkingen en onPause alleen voor het onderbreken van interactieve acties.

class VideoPlayerActivity : AppCompatActivity() {

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

    override fun onPause() {
        super.onPause()
        // App verliest focus — video pauzeren
        exoPlayer?.let { player ->
            if (player.isPlaying) {
                currentPosition = player.currentPosition
                player.pause()
            }
        }
        // Gevoelige gegevens verbergen (GDPR/bankschermen)
        if (window.decorView.systemUiVisibility and
            View.SYSTEM_UI_FLAG_SECURE == 0
        ) {
            hideSensitiveOverlay()
        }
    }

    override fun onResume() {
        super.onResume()
        // Focus terugkeer — afspelen hervatten
        exoPlayer?.seekTo(currentPosition)
        exoPlayer?.play()
        showSensitiveOverlay()
    }

    private fun hideSensitiveOverlay() {
        // Zwart scherm over financiële gegevens plaatsen
    }
}

De code toont de correcte afhandeling van onPause voor een videospeler. ExoPlayer wordt gepauzeerd bij focusverlies en de afspeelpositie wordt opgeslagen. Bij terugkeer naar onResume hervat de speler het afspelen vanaf de opgeslagen positie. Daarnaast wordt het patroon voor het verbergen van gevoelige gegevens getoond — belangrijk voor financiële en medische apps die bescherming nodig hebben tegen schermafbeeldingen bij het schakelen.

Beste praktijken voor het afhandelen van Inactive

Eerste regel — verberg vertrouwelijke gegevens bij de overgang naar Inactive. Wanneer de gebruiker Control Center of App Switcher opent, maakt iOS een schermafbeelding van het huidige scherm. Op Android vergelijkbaar — het systeem toont een voorbeeld van de laatste Activity in Recents. Gebruik UIApplication.shouldSnapshotSecureApp (iOS 16+) of FLAG_SECURE (Android) voor de bescherming van vertrouwelijke schermen.

Tweede regel — onderbreek animaties en media. Inactive is niet de beste tijd voor het afspelen van video of animaties, omdat de gebruiker ze niet ziet. Bovendien kan afspelen op de achtergrond leiden tot overlapping van geluiden met systeemgeluiden (oproep, melding). Stop AVPlayer, ExoPlayer en UIView.animate bij de overgang naar Inactive en hervat bij terugkeer naar Active.

Derde regel — blokkeer gegevensinvoer. Als de app invoerformulieren of concepten bevat, blokkeer dan het toetsenbord en invoervelden bij de overgang naar Inactive. Dit voorkomt accidentele invoer bij terugkeer en beschermt tegen onderschepping van gegevens via systeemoverlays. Schakel op iOS de first responder uit (view.endEditing(true)), op Android — wis de focus (currentFocus?.clearFocus()).

Vierde regel — voer geen lange bewerkingen uit in applicationWillResignActive of onPause. Deze methoden moeten binnen fracties van seconden worden voltooid. Als u een grote hoeveelheid gegevens moet opslaan, begin dan met opslaan op de achtergrondthread en voltooi het in applicationDidEnterBackground of onStop. iOS geeft 5 seconden voor het uitvoeren van applicationWillResignActive, waarna het systeem de app geforceerd kan beëindigen.

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
    }
}

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

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

De code toont de implementatie van een veilige overlay voor gegevensbescherming bij de overgang naar Inactive. UIVisualEffectView met een blur-effect wordt over de hele UI geplaatst bij de overgang naar Inactive en verwijderd bij terugkeer naar Active. Dit garandeert dat vertrouwelijke gegevens niet zichtbaar zijn op schermafbeeldingen van App Switcher en Control Center. Vergelijkbaar kan UIImageView met een logo worden gebruikt voor een branded overlay.