UIKit — cos'è, concetti chiave e architettura

Cos'è UIKit?

UIKit è un framework di Apple che fornisce classi per creare e gestire interfacce utente su iOS, iPadOS e macOS (tramite Mac Catalyst). Funziona sopra Core Animation, Core Graphics e Quartz Core, astraendo il rendering di basso livello in oggetti di alto livello — pulsanti, etichette, immagini e contenitori. UIKit ha debuttato con iPhone OS 1 nel 2007 e rimane il framework principale per lo sviluppo iOS insieme a SwiftUI.

Il framework segue un approccio imperativo: lo sviluppatore crea istanze delle classi UIButton, UILabel, UIImageView, imposta le loro proprietà (colore, font, posizione) e le aggiunge alla gerarchia delle viste tramite addSubview. Ogni modifica all'interfaccia viene eseguita esplicitamente — nessun aggiornamento magico dietro le quinte. Questo distingue UIKit dai framework dichiarativi come SwiftUI, dove la descrizione dello stato ridisegna automaticamente l'interfaccia.

Classi principali di UIKit

Il framework include diverse categorie di classi. UIView è l'elemento base da cui ereditano tutti i componenti visivi. UIWindow è il contenitore di livello superiore attraverso il quale le viste vengono visualizzate sullo schermo. UIViewController gestisce un insieme di viste e risponde alle rotazioni dello schermo, alla comparsa della tastiera e alle notifiche di sistema. UIApplication è il punto di ingresso che elabora gli eventi tattili e le pressioni dei pulsanti.

Per il testo si utilizzano UILabel (testo statico), UITextField (input a riga singola), UITextView (input multi-riga). Per i pulsanti — UIButton, inclusi pulsanti di sistema, personalizzati e con iconografia SF Symbols. Per la navigazione — UINavigationController, UITabBarController e UISplitViewController. In totale, UIKit ha oltre 200 classi pubbliche.

Architettura di UIKit: livelli e gerarchia delle viste

L'architettura di UIKit è costruita su livelli: ogni livello è responsabile di un aspetto della visualizzazione. Al livello più basso si trova Core Graphics — il motore di rendering di percorsi, testo e immagini. Sopra c'è Core Animation, che gestisce la composizione dei livelli (CALayer) e le animazioni tra stati. UIKit costruisce su di essi un'API orientata agli oggetti: UIView, UIViewController e UIResponder.

Ogni applicazione ha una gerarchia di viste — un albero la cui radice è UIWindow. Sotto si trova il UIViewController radice, la sua vista e le subview annidate al suo interno. Gli eventi tattili si propagano lungo la catena di risposta: dalla vista più annidata ai suoi genitori e fino a UIApplication. Se nessun oggetto gestisce il tocco, viene ignorato.

UIView e CALayer

Ogni UIView contiene un CALayer che gestisce il rendering dei pixel sullo schermo. La vista gestisce i tocchi e l'accessibilità; il livello gestisce la grafica — ombra, cornerRadius, bordo, trasformazione. Questa separazione permette di scaricare la grafica pesante su un thread separato (server di rendering) senza bloccare il thread principale. Apple raccomanda di lavorare direttamente con CALayer se ci sono più di 200 viste sullo schermo — questo riduce il carico della CPU.

Catena di risposta in dettaglio

La catena di risposta inizia con l'oggetto che riceve per primo un evento tattile. Se non gestisce l'evento (il metodo touchesBegan non è stato sovrascritto), l'evento passa al risponditore successivo nella catena: next, superview, next responder, UIViewController, UIWindow, UIApplication, App Delegate. Ciò consente di intercettare gesti globali ed eventi della tastiera a livello di scena senza aggiungere un gestore a ogni vista.

Ciclo di vita di UIViewController

Ogni UIViewController attraversa una sequenza di eventi rigorosamente definita. Il ciclo di vita include fasi: inizializzazione, caricamento della vista, comparsa sullo schermo, aggiornamento del layout in rotazione, occultamento, uscita dallo schermo e liberazione della memoria. Lo sviluppatore sovrascrive i metodi corrispondenti per eseguire codice personalizzato in ogni fase.

class ProfileViewController: UIViewController {

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

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

    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        clearCache()
    }
}

In viewDidLoad, l'interfaccia viene configurata — le subview vengono create, i vincoli vengono impostati, i delegati vengono sottoscritti. In viewWillAppear, vengono eseguite operazioni prima della visualizzazione: caricamento di dati freschi dalla rete, aggiornamento dei valori. viewDidDisappear è il posto per annullare la sottoscrizione alle notifiche e pulire i dati temporanei. La chiamata a super è obbligatoria in tutte le sovrascritture, altrimenti la catena di eventi si rompe.

Gestione della memoria e viewDidUnload

Nelle vecchie versioni di iOS esisteva il metodo viewDidUnload, chiamato in caso di memoria insuffciente. Da iOS 6, il metodo è stato rimosso — UIKit ora scarica automaticamente le viste dei controller quando non sono visibili. Lo sviluppatore deve solo dichiarare tutti i riferimenti alle viste come weak affinché ARC possa liberare correttamente la memoria al ricevimento di un avviso di sistema.

Transizioni tra controller

UIKit supporta due tipi di transizioni: segue (tramite Storyboard) e navigazione programmatica attraverso UINavigationController. Una transizione programmatica ha questo aspetto: navigationController?.pushViewController(detailVC, animated: true). In questo caso, il ciclo di vita di detailVC procede normalmente — viewDidLoad viene chiamato una volta, viewWillAppear viene chiamato ogni volta che appare.

Auto Layout e layout adattivo

Auto Layout è un sistema di posizionamento basato su relazioni matematiche (vincoli). Invece di coordinate X e Y hard-coded, lo sviluppatore descrive regole: “il pulsante è a destra dell'etichetta con un margine di 16pt” o “la vista si estende per tutta la larghezza dello schermo con margini di 20pt a sinistra e a destra.” Il sistema risolve il sistema di equazioni risultante in fase di esecuzione, adattando l'interfaccia a qualsiasi dimensione dello schermo.

I vincoli possono essere impostati in Interface Builder (tramite drag-and-drop) o programmaticamente in Swift. Ogni vincolo è un'istanza della classe NSLayoutConstraint con parametri: firstItem, firstAttribute, relation, secondItem, secondAttribute, multiplier, constant. I vincoli vengono attivati tramite isActive = true o in massa tramite NSLayoutConstraint.activate().

Safe Area e Layout Margins

Con l'introduzione dell'iPhone X (2017), Apple ha introdotto la Safe Area — l'area dello schermo libera dal notch, dagli angoli arrotondati e dall'indicatore della home bar. I vincoli dovrebbero essere collegati a view.safeAreaLayoutGuide, non a view. I Layout Margins aggiungono un padding interno alla vista, per impostazione predefinita 8pt o 16pt a seconda del contesto. L'uso di safeAreaLayoutGuide garantisce una visualizzazione corretta su tutte le generazioni di iPhone e iPad.

Animazione dei vincoli

Auto Layout supporta l'animazione modificando le costanti dei vincoli. Basta aggiornare la constant di un vincolo e chiamare UIView.animate con layoutIfNeeded all'interno del blocco di animazione. Il sistema ricalcola senza problemi la posizione di tutte le viste nella gerarchia. Questa tecnica viene utilizzata per blocchi espandibili, pannelli della tastiera adattivi e cambi di orientamento dello schermo.

Lavorare con tabelle e collezioni

UITableView e UICollectionView sono due potenti strumenti di UIKit per visualizzare elenchi e griglie. UITableView è adatta per elenchi verticali a colonna singola (chat, impostazioni, feed notizie). UICollectionView è per griglie, elenchi orizzontali, caroselli e layout personalizzati (galleria, prodotti, calendario). Entrambe le classi utilizzano il modello di delega per separare i dati dall'aspetto.

La sorgente dati è il protocollo UITableViewDataSource con i metodi obbligatori numberOfRowsInSection e cellForRowAt. Il UITableViewDelegate gestisce i tocchi sulle celle, l'altezza delle righe e gli eventi di scorrimento. Il meccanismo di reuse identifier riutilizza le celle uscite dallo schermo, il che è fondamentale per le prestazioni su elenchi grandi.

class ContactsViewController: UITableViewController {

    private let contacts = ["Anna", "Boris", "Victor"]

    override func viewDidLoad() {
        super.viewDidLoad()
        tableView.register(UITableViewCell.self,
                           forCellReuseIdentifier: "cell")
    }

    override func tableView(_ tableView: UITableView,
                          numberOfRowsInSection section: Int) -> Int {
        return contacts.count
    }

    override func tableView(_ tableView: UITableView,
                          cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "cell",
                                                 for: indexPath)
        var content = cell.defaultContentConfiguration()
        content.text = contacts[indexPath.row]
        cell.contentConfiguration = content
        return cell
    }
}

L'esempio mostra un controller minimo per visualizzare un array di stringhe. La cella viene configurata tramite UIListContentConfiguration — un'API moderna (iOS 14+) che ha sostituito i deprecati textLabel e detailTextLabel. La registrazione della classe della cella in viewDidLoad è obbligatoria, altrimenti l'applicazione si blocca con un'eccezione in fase di esecuzione.

UICollectionView e Compositional Layout

A partire da iOS 13, Apple raccomanda UICollectionViewCompositionalLayout per costruire layout complessi. Lo sviluppatore descrive la sezione, il gruppo, l'elemento e le loro dimensioni in modo dichiarativo — ottenendo una griglia con geometria arbitraria: una striscia, griglia 2x2, carosello o ornamento. Compositional Layout ha sostituito il deprecato UICollectionViewFlowLayout per tutti i nuovi progetti. In combinazione con DiffableDataSource, l'aggiornamento di una collezione si riduce a una singola chiamata apply(snapshot) e le animazioni di modifica vengono eseguite automaticamente.

Esempi di codice Swift

Di seguito sono riportati due esempi pratici di utilizzo di UIKit in attività reali: creare una vista personalizzata con ombra e angoli arrotondati e gestire un gesto di scorrimento per eliminare un elemento da un elenco.

extension UIView {
    func applyCardStyle() {
        layer.cornerRadius = 12
        layer.shadowOpacity = 0.15
        layer.shadowRadius = 8
        layer.shadowOffset = CGSize(width: 0, height: 2)
        layer.masksToBounds = false
    }
}

@objc private func handleSwipe(_ gesture: UISwipeGestureRecognizer) {
    guard let swipedView = gesture.view else { return }
    UIView.animate(withDuration: 0.3) {
        swipedView.alpha = 0
        swipedView.transform = CGAffineTransform(translationX: 300, y: 0)
    } completion: { _ in
        swipedView.removeFromSuperview()
    }
}

L'estensione applyCardStyle aggiunge ombra e angoli arrotondati a qualsiasi vista — utile per schede prodotto, profili e notifiche. Il metodo handleSwipe con animazione elimina un elemento quando l'utente scorre verso destra su di esso. Il gestore viene aggiunto alla vista tramite addGestureRecognizer con una configurazione UISwipeGestureRecognizer(direction: .right). Impostare masksToBounds = false è importante per evitare che l'ombra venga tagliata dai bordi della vista.

Per interfacce più complesse, utilizzare UIStackView — un contenitore che distribuisce automaticamente le viste annidate orizzontalmente o verticalmente. Stack View semplifica il layout: non è necessario impostare vincoli per ogni elemento, basta un vincolo per lo stack stesso.