ViewController — lényege, képernyővezérlő iOS-ben és életciklusa

Mi az a ViewController?

UIViewController — egy osztály a UIKit keretrendszerből, amely a UIView hierarchiát kezeli és összehangolja az adatok képernyőn történő megjelenítését. Minden iOS alkalmazás tartalmaz legalább egy ViewController-t — az ablak gyökérvezérlőjét. A vezérlő kezeli a képernyőelforgatásokat, a képernyők közötti átmeneteket és az életciklus eseményeket.

Az MVC (Model-View-Controller) architektúra iOS-ben pontosan az UIViewController-en keresztül valósul meg: a vezérlő adatokat kap a modelltől és frissíti a nézetet. A ViewController nem vizuális elem — a view tulajdonságot kezeli, amely a subview hierarchiát tartalmazza. Az Apple adatai szerint (2026) a UIKit több mint 40 beépített UIViewController alosztályt tartalmaz.

Az első iPhone SDK (2008) három életciklus metódussal rendelkező UIViewController-t tartalmazott. 18 év alatt az Apple hozzáadta a Container View Controller támogatását, adaptív prezentációkat, UIViewControllerTransitioningDelegate-et egyedi animációkhoz és osztott képernyő módot iPad-en. Az UIViewController továbbra is kötelező komponens marad a UIKit alkalmazásokhoz.

Az UIViewController életciklusa

Az UIViewController életciklusa — a rendszer által a képernyő létrehozásakor, megjelenítésekor és elrejtésekor meghívott metódusok sorozata. Az életciklus megértése kritikus fontosságú: a kód helytelen elhelyezése memóriaszivárgáshoz, felesleges hálózati kérésekhez és a felület villogásához vezet.

Meghívási sorrend a képernyő megjelenésekor

A képernyő első megjelenésekor: init → loadView → viewDidLoad → viewWillAppear → viewDidAppear. Újbóli megjelenéskor (visszatérés másik képernyőről): viewWillAppear → viewDidAppear. A viewDidLoad csak egyszer hívódik meg a vezérlő élettartama során.

viewDidLoad, init és UI beállítás

A viewDidLoad metódus — a felhasználói felület beállításának fő pontja. A view memóriába töltése után hívódik meg, amikor az összes IBOutlet már csatlakoztatva van. Itt jönnek létre programozottan a UI elemek, kerülnek beállításra a constraint-ek, töltődnek be a kezdeti adatok.

final class ProfileViewController: UIViewController {

    private let tableView = UITableView()
    private let viewModel = ProfileViewModel()

    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        bindViewModel()
    }

    private func setupUI() {
        view.addSubview(tableView)
        tableView.translatesAutoresizingMaskIntoConstraints = false
        NSLayoutConstraint.activate([
            tableView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
            tableView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            tableView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
        ])
        tableView.register(ProfileCell.self,
                         forCellReuseIdentifier: ProfileCell.reuseId)
    }

    private func bindViewModel() {
        viewModel.$user
            .receive(on: DispatchQueue.main)
            .sink { [weak self] user in
                self?.title = user.name
            }
            .store(in: &cancellables)
    }
}

SwiftUI-ben ez a kód a View törzsének felel meg. De az UIViewController teljes ellenőrzést biztosít az életciklus és az optimalizálás felett. A bindViewModel a Combine-t használja reaktív feliratkozáshoz — az adatok automatikusan frissülnek a modell változásakor.

viewWillAppear és adatfrissítés

A viewWillAppear minden alkalommal meghívódik a képernyő megjelenése előtt, még akkor is, ha az már a memóriában volt. Ez a hely azon adatok frissítésére, amelyek egy másik képernyőn változhattak: lista újratöltése, értesítésszámláló frissítése, navigation bar beállítása az adott képernyőhöz.

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)

    // Navigation bar elrejtése ezen a képernyőn
    navigationController?.setNavigationBarHidden(true, animated: animated)

    // Adatok frissítése másik képernyőről való visszatéréskor
    tableView.reloadData()
    badgeLabel.text = "\(CartManager.shared.itemCount)"
}

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)

    // Analitika: csak miután a felhasználó látta a képernyőt
    AnalyticsService.shared.logScreenView("Profile")
}

A viewDidLoad és a viewWillAppear közötti különbség kritikus: a viewDidLoad egyszer fut le és statikus beállításra alkalmas, a viewWillAppear — minden megjelenítéskor, dinamikus frissítésekre alkalmas. A hálózati kérések viewDidLoad-ba helyezése elavult adatok megjelenítéséhez vezet a képernyőre való visszatéréskor.

Container View Controller: UINavigationController és UITabBarController

Container View Controller — egy ViewController, amely egy vagy több gyermek ViewController-t kezel. Az Apple három beépített konténert kínál: UINavigationController (képernyőverem), UITabBarController (lapok) és UISplitViewController (master-detail iPad-hez).

Az UINavigationController veremben szervezi az átmeneteket — a push hozzáad egy képernyőt, a pop eltávolítja. Az UITabBarController az alkalmazás független szekciói között vált. Az UISplitViewController két vezérlőt mutat egymás mellett iPad-en és egyet iPhone-on. A fejlesztő saját konténert hozhat létre az addChild segítségével.

// Egyéni Container View Controller
final class ContainerViewController: UIViewController {

    private let sidebarVC = SidebarViewController()
    private let contentVC = ContentViewController()

    override func viewDidLoad() {
        super.viewDidLoad()

        // Gyermek vezérlő hozzáadása
        addChild(sidebarVC)
        view.addSubview(sidebarVC.view)
        sidebarVC.didMove(toParent: self)

        addChild(contentVC)
        view.addSubview(contentVC.view)
        contentVC.didMove(toParent: self)
    }
}

A Container View Controller-rel való helyes munka az addChild, a view hozzáadása és a didMove(toParent:) meghívását igényli ebben a sorrendben. Eltávolításkor — willMove(toParent: nil), removeFromSuperview, removeFromParent. A sorrend megsértése memóriaszivárgáshoz vezet.

A Massive View Controller megoldása MVVM és Coordinator segítségével

A Massive View Controller problémája — amikor az UIViewController több száz sornyi kódot tartalmaz üzleti logikával, hálózati kérésekkel, navigációval és UI kóddal. Az Apple tisztában van a problémával, és az MVVM (Model-View-ViewModel) használatát javasolja a Coordinator mellett a navigáció szétválasztására.

Az MVVM átviszi az üzleti logikát a vezérlőből a ViewModel-be. A Controller csak a ViewModel-t kapcsolja össze a View-val Combine vagy delegate segítségével. A Coordinator a navigációs logikát — a vezérlők létrehozását és a köztük lévő átmeneteket — külön osztályba helyezi. Ez a megközelítés 2024-től bekerült az Apple legjobb gyakorlatai közé.

// Coordinator — navigáció kezelése
protocol Coordinator {
    var childCoordinators: [Coordinator] { get set }
    func start()
}

final class MainCoordinator: Coordinator {

    var childCoordinators = [Coordinator]()
    private let navigationController: UINavigationController

    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }

    func start() {
        let vc = ListViewController()
        vc.didSelectItem = { [weak self] item in
            self?.showDetail(item)
        }
        navigationController.pushViewController(vc, animated: false)
    }

    private func showDetail(_ item: Item) {
        let vc = DetailViewController(item: item)
        navigationController.pushViewController(vc, animated: true)
    }
}

UIViewController vs SwiftUI: mikor mit válasszunk

A választás az UIViewController és a SwiftUI View között a projekt kezdési évétől, a testreszabási követelményektől és a minimális támogatott iOS verziótól függ. A UIKit UIViewController-rel továbbra is alapot képez a 2020 előtt indított projektekhez és a mély felülettestreszabást igénylő alkalmazásokhoz.

A SwiftUI alkalmas új projektekhez iOS 17+, szabványos felületekhez és prototípusokhoz. Azonban egyéni átmenetekhez, kamerával való munkához, MapKit-hez, összetett CALayer animációkhoz UIViewController szükséges. Az Apple a megközelítések kombinálását javasolja az UIHostingController (SwiftUI UIKit-en belül) és az UIViewRepresentable (UIKit SwiftUI-n belül) segítségével.