Czy możesz opowiedzieć o cyklu życia aplikacji na…

Aplikacja przechodzi przez następujące stany:

Nie działa: Aplikacja nie jest uruchomiona.
Nieaktywny: Aplikacja jest uruchomiona, ale nie odbiera zdarzeń (np. podczas przychodzącego połączenia lub przejścia w tryb tła).
Aktywny: Aplikacja jest aktywna i w pełni funkcjonalna. Odbiera wszystkie zdarzenia.
Tło: Aplikacja jest w trybie tła. Może wykonywać ograniczony kod lub być zawieszona.
Zawieszona: Aplikacja w trybie tła, ale jej wykonanie jest zawieszone przez system w celu oszczędzania zasobów.

Przejścia między stanami i związane z nimi zdarzenia są zarządzane przez systemowy framework UIKit (lub SwiftUI) i delegata aplikacji (UIApplicationDelegate lub @main Struct w SwiftUI).

Kluczowe metody delegata aplikacji:

application:didFinishLaunchingWithOptions:: Aplikacja została uruchomiona.
applicationDidBecomeActive:: Aplikacja przechodzi w stan aktywny.
applicationWillResignActive:: Aplikacja przechodzi ze stanu aktywnego (np. podczas przychodzącego połączenia).
applicationDidEnterBackground:: Aplikacja przechodzi w tryb tła.
applicationWillEnterForeground:: Aplikacja przechodzi z tła do aktywnego stanu.
applicationWillTerminate:: Aplikacja kończy działanie.

Przykład użycia w App Delegate:

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Wykonuje się przy starcie aplikacji
        print("Aplikacja uruchomiona")
        return true
    }

    func applicationDidBecomeActive(_ application: UIApplication) {
        // Aplikacja stała się aktywna
        print("Aplikacja stała się aktywna")
    }

    func applicationWillResignActive(_ application: UIApplication) {
        // Aplikacja przechodzi ze stanu aktywnego
        print("Aplikacja przechodzi ze stanu aktywnego")
    }

    func applicationDidEnterBackground(_ application: UIApplication) {
        // Aplikacja przechodzi w tło
        print("Aplikacja przechodzi w tło")
    }

    func applicationWillEnterForeground(_ application: UIApplication) {
        // Aplikacja przechodzi na pierwszy plan
        print("Aplikacja przechodzi na pierwszy plan")
    }

    func applicationWillTerminate(_ application: UIApplication) {
        // Aplikacja kończy działanie
        print("Aplikacja kończy działanie")
    }
}

W SwiftUI cykl życia jest zarządzany przez strukturę z @main i metody takie jak onAppear, onDisappear, onChange. Dostępne są też wartości środowiskowe, które pozwalają śledzić stan sceny (ScenePhase).

import SwiftUI

@main
struct MyApp: App {
    @Environment(\.scenePhase) var scenePhase // Śledzenie stanu sceny

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { newPhase in
            if newPhase == .active {
                // Scena stała się aktywna
                print("Scena stała się aktywna")
            } else if newPhase == .inactive {
                // Scena stała się nieaktywna
                print("Scena stała się nieaktywna")
            } else if newPhase == .background {
                // Scena przeszła w tło
                print("Scena przeszła w tło")
            }
        }
    }
}

Czy możesz opowiedzieć o cyklu życia aplikacji na iOS?