Levenscyclus in mobiele ontwikkeling: wat het is, welke fasen en hoe het werkt

Levenscyclus van de app (App Lifecycle)

Voordat we ingaan op de levenscyclus van individuele schermen, is het belangrijk de levenscyclus van de hele app te begrijpen. In iOS doorloopt de app vijf statussen: Not Running (niet actief), Inactive (op achtergrond, ontvangt geen gebeurtenissen), Active (actief), Background (op achtergrond, code wordt uitgevoerd) en Suspended (op achtergrond, code gepauzeerd). Deze statussen worden beheerd in AppDelegate via de methoden applicationDidFinishLaunching, applicationDidBecomeActive, applicationWillResignActive, applicationDidEnterBackground en applicationWillTerminate.

In Android is het equivalent de Application Lifecycle, bijgehouden via de interface Application.ActivityLifecycleCallbacks. Android richt zich echter meer op de levenscyclus van een Activity — een individueel app-scherm. Dit komt doordat een Android-app uit meerdere Activities kan bestaan, elk met een eigen cyclus.

De moderne aanpak in Android is het gebruik van ProcessLifecycleOwner uit de lifecycle-process bibliotheek. Het maakt het mogelijk de status van het hele proces te volgen zonder gebonden te zijn aan een specifieke Activity. In iOS wordt UISceneDelegate (sinds iOS 13) of AppDelegate gebruikt voor het volgen van de app-status. SceneDelegate beheert meerdere vensters (multiwindow) op iPad. Het begrijpen van de App Lifecycle is vooral belangrijk voor IT Sectr bij het ontwikkelen van apps met achtergrondsynchronisatie, streaming en VoIP-gesprekken.

Activity Lifecycle in Android

Activity is de basiscomponent van een Android-app die één scherm vertegenwoordigt. Activity heeft een duidelijk gedefinieerde levenscyclus die wordt beheerd door het besturingssysteem in reactie op gebruikersacties en systeemgebeurtenissen (schermrotatie, inkomend gesprek, weinig geheugen).

Belangrijk: onSaveInstanceState wordt aangeroepen vóór onStop om de tijdelijke status op te slaan. Herstel vindt plaats in onCreate via Bundle savedInstanceState of via SavedStateHandle in ViewModel. Zonder correcte levenscyclusbehandeling verliest de app alle niet-opgeslagen gegevens bij schermrotatie.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("draft", draftText)
    }
    override fun onDestroy() {
        super.onDestroy()
        // Отписка от всех подписок
    }
}

Activity Lifecycle in Jetpack Compose

In Jetpack Compose blijft de Activity-levenscyclus ongewijzigd, maar Compose biedt extra hulpmiddelen: Levenscyclusbewuste compositie via LifecycleOwner, LifecycleEventEffect en DisposableEffect voor automatische opschoning van bronnen bij vernietiging.

Fragment Lifecycle in detail

Fragment in Android leeft binnen een Activity en heeft zijn eigen levenscyclus, die gedeeltelijk overlapt met Activity maar nieuwe methoden toevoegt. Fragmenten kunnen worden toegevoegd, vervangen en verwijderd zonder de Activity te vernietigen, wat ze flexibeler maar ook complexer maakt.

Belangrijkste methoden van Fragment Lifecycle: onAttach — Fragment aan Activity gekoppeld (eerste aanroep); onCreate — gegevensinitialisatie; onCreateView — View-creatie; onViewCreated — View gemaakt, UI kan worden geconfigureerd; onStart — Fragment zichtbaar; onResume — Fragment in focus; onPause — Fragment verliest focus; onStop — Fragment niet zichtbaar; onDestroyView — View vernietigd; onDestroy — Fragment vernietigd; onDetach — Fragment losgekoppeld van Activity.

Belangrijkste verschil met Activity: onCreateView en onDestroyView kunnen meerdere keren worden aangeroepen (bijv. bij het wisselen van TabLayout), terwijl onCreate eenmalig wordt aangeroepen. Dienovereenkomstig moet View-initialisatie plaatsvinden in onViewCreated, niet in onCreateView. View-gerelateerde bronnen (zoals RecyclerView-adapters) moeten worden opgeschoond in onDestroyView.

ViewController Lifecycle in iOS

UIViewController is de basisklasse voor het beheren van schermen in iOS. De levenscyclus bestaat uit een reeks methoden die UIKit automatisch aanroept. Het begrijpen van deze cyclus is cruciaal voor correcte UI-initialisatie, gegevensbeheer en geheugenbeheer.

Belangrijk: viewDidLoad wordt slechts eenmaal aangeroepen in de levensduur van een View Controller. Gebruik viewWillAppear om gegevens bij te werken bij elke verschijning. Als u zich abonneert op NotificationCenter in viewWillAppear, zorg dan dat u uitschrijft in viewDidDisappear om geheugenlekken te voorkomen.

SwiftUI Lifecycle

SwiftUI beheert de levenscyclus van Views via View-structuren. In plaats van callback-methoden gebruikt SwiftUI de modifiers onAppear en onDisappear. Voor globale app-statussen wordt de App Lifecycle gebruikt via de App- en Scene-protocollen. SwiftUI beheert automatisch het maken en vernietigen van Views op basis van de status, wat ontwikkeling vereenvoudigt maar begrip van View-identiteit en levensduur vereist.

struct ContentView: View {
    var body: some View {
        Text("Hello")
            .onAppear {
                print("View появилась")
            }
            .onDisappear {
                print("View исчезла")
            }
    }
}

LifecycleOwner en LifecycleObserver in Android

LifecycleOwner is een interface van Android Architecture Components die een object markeert met een levenscyclus (Activity, Fragment). LifecycleObserver is een interface die een object in staat stelt zich te abonneren op LifecycleOwner-gebeurtenissen. Samen vormen ze de basis van reactief levenscyclusbeheer in moderne Android-ontwikkeling.

In plaats van methoden expliciet aan te roepen in onStart/onStop, wordt aanbevolen DefaultLifecycleObserver te gebruiken (vervanging voor de verouderde LifecycleObserver met @OnLifecycleEvent-annotaties). Dit is de door Google gepromote aanpak voor ViewModel en andere componenten die moeten reageren op de levenscyclus zonder directe verwijzingen naar Activity of Fragment.

class MyObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // Подписка на обновления
    }
    override fun onStop(owner: LifecycleOwner) {
        // Отписка
    }
}

Bij IT Sectr gebruiken we LifecycleOwner in alle Android-projecten. ViewModel abonneert zich op de LifecycleOwner van Activity via viewModelScope en lifecycleScope, wat automatische annulering van coroutines garandeert wanneer de Activity wordt vernietigd. Dit voorkomt geheugenlekken en maakt de code schoner en veiliger.