iPadOS: concetti chiave, sviluppo per iPad e Apple Pencil

Cos'è iPadOS?

iPadOS è il sistema operativo di Apple per iPad, rilasciato per la prima volta nel 2019 come fork di iOS (versione 13). Prima di questo, l'iPad utilizzava lo stesso iOS dell'iPhone. La separazione di iPadOS ha permesso ad Apple di introdurre funzionalità specifiche per il grande schermo: multitasking, Safari desktop, trascinamento e supporto per monitor esterni.

iPadOS mantiene la piena compatibilità con le app iOS: qualsiasi app per iPhone viene eseguita su iPad in modalità di ridimensionamento. Tuttavia, un'esperienza utente di qualità richiede un adattamento: utilizzare Size Classes, UISplitViewController e supporto per scorciatoie da tastiera. Secondo Apple (WWDC 2025), l'80% del tempo su iPad gli utenti lo trascorrono in versioni ottimizzate per tablet, non in versioni ridimensionate.

Cronologia delle versioni di iPadOS

iPadOS 13 (2019) ha introdotto Slide Over e Split View. iPadOS 14 (2020) ha aggiunto Apple Pencil Scribble e interfaccia compatta. iPadOS 15 (2021) ha introdotto Quick Note e miglioramenti del multitasking. iPadOS 16 (2022) ha portato Stage Manager e supporto per monitor esterni. iPadOS 17 (2023) ha aggiunto widget interattivi e personalizzazione della schermata di blocco.

Architettura di iPadOS e differenze da iOS

iPadOS si basa sullo stesso kernel XNU e Darwin di iOS, ma utilizza una shell UIKit modificata adattata per più finestre e dimensioni dello schermo arbitrarie. La differenza architetturale chiave è il supporto di UIScene, introdotto in iOS 13.

UIScene e ciclo di vita delle finestre

In iPadOS, ogni finestra (incluse quelle in Split View) è una UISceneSession separata con il proprio ciclo di vita. A differenza dell'iPhone, dove un'app ha una singola UIWindowScene, su iPad un'app può avere più UIScene (più finestre, Slide Over, Stage Manager). SceneDelegate gestisce lo stato di ogni finestra in modo indipendente.

import UIKit
import SwiftUI

/// SceneDelegate per il supporto di più finestre su iPadOS
class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?
    var splitVC: UISplitViewController?

    func scene(_ scene: UIScene,
                 willConnectTo session: UISceneSession,
                 options connectionOptions: UIScene.ConnectionOptions) {
        guard let windowScene = (scene as? UIWindowScene) else { return }

        // Creazione di UISplitViewController per la navigazione su tablet
        let splitVC = UISplitViewController(style: .tripleColumn)
        splitVC.primaryBackgroundStyle = .sidebar

        let sidebar = SidebarViewController()
        let primary = PrimaryViewController()
        let detail = DetailViewController()

        splitVC.viewControllers = [sidebar, primary, detail]

        let window = UIWindow(windowScene: windowScene)
        window.rootViewController = splitVC
        window.makeKeyAndVisible()
        self.window = window
    }

    // Adattamento al cambiamento delle dimensioni della finestra (Split View)
    func windowScene(_ windowScene: UIWindowScene,
                     didUpdate previousCoordinateSpace: UICoordinateSpace,
                     interfaceOrientation previousOrientation: UIInterfaceOrientation) {
        let isMultitasking = windowScene.traitCollection.horizontalSizeClass == .compact
        print("iPadOS multitasking mode: \(isMultitasking ? "compact" : "regular")")
    }
}

UISplitViewController con stile .tripleColumn visualizza tre colonne simultaneamente: barra laterale (navigazione), primaria (elenco) e dettaglio (contenuto). Quando si passa alla modalità compatta (Split View con un'altra app), UIKit comprime automaticamente le colonne in una pila di navigazione. Lo sviluppatore non gestisce questo comportamento manualmente — UIKit adatta il layout tramite traitCollection.

Differenze aggiuntive da iOS

iPadOS offre: supporto per archiviazioni esterne tramite Files (USB-C/Thunderbolt), modalità terminale di Safari con ispezione elementi, scorciatoie da tastiera tramite UIKeyCommand, gestore download di sistema, trascinamento tra app e Picture in Picture con finestra ridimensionabile.

Multitasking su iPad: Split View, Slide Over, Stage Manager

Il multitasking è una caratteristica chiave di iPadOS che lo distingue fondamentalmente da iOS. L'utente può lavorare simultaneamente con più app su un unico schermo. Lo sviluppatore deve garantire che l'app funzioni correttamente in qualsiasi modalità multitasking.

Split View

Split View divide lo schermo dell'iPad tra due app in un rapporto 50/50 o 33/67. Ogni app riceve la propria UISceneSession con la propria memoria e ciclo di vita. Quando la larghezza dello schermo è inferiore a 600 punti, UIKit forza l'app a una size class orizzontale compatta. L'app deve gestire correttamente questo cambiamento.

Slide Over

Slide Over è una finestra fluttuante sopra l'app attiva (larghezza 320 punti). Un'app in Slide Over passa a una size class orizzontale compatta (.compact). È importante ottimizzare l'interfaccia per uno schermo stretto. In Slide Over, l'app può essere invocata scivolando dal bordo destro o tramite il dock. L'utente può trascinare Slide Over in Split View o chiuderlo scivolando verso destra.

Stage Manager

Stage Manager (iPadOS 16+, M1 e successivi) è un gestore di finestre che consente di creare finestre sovrapposte di dimensioni arbitrarie. Sono supportate fino a 4 finestre sullo schermo dell'iPad e fino a 4 su un monitor esterno (8 in totale). Le app ricevono l'evento UISceneWillConnectNotification per ogni nuova finestra. Stage Manager modificano le regole del ciclo di vita: una finestra in background non viene congelata ma continua a funzionare con risorse limitate.

Apple Pencil e input scritto a mano

Apple Pencil è la penna attiva di Apple con supporto per inclinazione, pressione e rilevamento hover (iPad Pro M2+). La latenza tra il movimento della penna e la visualizzazione dell'inchiostro è di 9–20 ms a seconda del modello. PencilKit è il framework principale per integrare il disegno in un'app.

PencilKit: Integrazione del disegno

PKCanvasView fornisce una superficie di disegno pronta all'uso con supporto per inchiostro, matita, pennarello e gomma. PKToolPicker è il pannello di selezione degli strumenti. Lo sviluppatore non deve implementare il rendering dei tratti — PencilKit lo fa con accelerazione hardware tramite Metal shader. Sono disponibili la personalizzazione di colore, spessore e opacità della penna.

import PencilKit
import UIKit

class DrawingViewController: UIViewController {

    private lazy var canvasView: PKCanvasView = {
        let canvas = PKCanvasView()
        canvas.tool = PKInkingTool(.pen, color: .black, width: 5)
        canvas.delegate = self
        canvas.drawingPolicy = .anyInput
        canvas.backgroundColor = .white
        return canvas
    }()

    private lazy var toolPicker: PKToolPicker = {
        let picker = PKToolPicker()
        picker.addObserver(canvasView)
        picker.setVisible(true, forFirstResponder: canvasView)
        return picker
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        view.addSubview(canvasView)
        canvasView.frame = view.bounds
        canvasView.becomeFirstResponder()
        toolPicker.addObserver(canvasView)
    }

    // Salvataggio del disegno in PKDrawing (formato binario)
    func saveDrawing() {
        let drawingData = canvasView.drawing.dataRepresentation()
        let url = FileManager.default.urls(
            for: .documentDirectory, in: .userDomainMask
        )[0].appendingPathComponent("drawing.drawing")
        try? drawingData.write(to: url)
    }
}

extension DrawingViewController: PKCanvasViewDelegate {
    func canvasViewDrawingDidChange(_ canvasView: PKCanvasView) {
        print("Canvas changed: \(canvasView.drawing.strokes.count) strokes")
    }
}

PKCanvasView con drawingPolicy .anyInput accetta sia l'input Apple Pencil che il dito. PKToolPicker offre all'utente la selezione degli strumenti senza dover scrivere un'interfaccia personalizzata. PKDrawing viene archiviato in formato binario con alta compressione — un'ora di disegno occupa circa 5–10 MB.

Scribble e riconoscimento del testo

Scribble (iPadOS 14+) consente di scrivere a mano in qualsiasi UITextField e UITextView. Il sistema riconosce la scrittura a mano sul dispositivo utilizzando il Neural Engine. Il modello ML funziona con alfabeto latino e cirillico. In iOS 17+, Scribble supporta la correzione automatica e la previsione della parola successiva. Lo sviluppatore non deve aggiungere codice — Scribble funziona automaticamente con qualsiasi campo di input.

Hover API per Apple Pencil Pro

A partire da iPadOS 17.4 e Apple Pencil Pro, gli sviluppatori ottengono eventi hover quando la penna si avvicina allo schermo (fino a 12 mm). L'evento contiene posizione, forza e azimut. Applicazioni: anteprima del punto di contatto del pennello nelle app di disegno, anteprima dello strumento, feedback visivo prima del tocco.

Adattamento dell'interfaccia per iPad

Interfaccia adattiva è un requisito obbligatorio per le app iPad. L'iPad funziona con diverse dimensioni dello schermo (8,3"–13") e modalità multitasking. UIKit fornisce Size Classes (orizzontale: .regular/.compact, verticale: .regular/.compact) e UISplitViewController per l'adattamento automatico.

Size Classes e traitCollection

Size Classes sono un'astrazione che definisce lo spazio disponibile. Su iPad in modalità schermo intero, entrambi gli assi sono .regular. In Split View (50%), la classe orizzontale può diventare .compact su iPad mini o iPad Air. Tutti i layout popolari realizzati con Auto Layout e UICollectionViewCompositionalLayout si adattano automaticamente. L'adattamento personalizzato viene eseguito sovrascrivendo traitCollectionDidChange.

import SwiftUI

/// Layout adattivo per iPad utilizzando Size Classes
struct AdaptiveContentView: View {
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
    @Environment(\.verticalSizeClass) private var verticalSizeClass

    var body: some View {
        if horizontalSizeClass == .regular && verticalSizeClass == .regular {
            // Modalità tablet: barra laterale + contenuto
            NavigationSplitView {
                SidebarView()
            } detail: {
                ContentGridView()
            }
        } else {
            // Modalità compatta: navigazione in pila
            NavigationStack {
                ContentGridView()
            }
        }
    }
}

/// Esempio di griglia adattiva: 3 colonne su iPad, 2 su iPhone
struct ContentGridView: View {
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass

    private var columns: [GridItem] {
        let count = horizontalSizeClass == .regular ? 3 : 2
        return Array(repeating: GridItem(.flexible(), spacing: 16), count: count)
    }

    var body: some View {
        ScrollView {
            LazyVGrid(columns: columns, spacing: 16) {
                ForEach(items) { item in
                    ItemCard(item: item)
                }
            }
            .padding()
        }
    }
}

Nell'esempio, NavigationSplitView viene utilizzato solo quando horizontalSizeClass == .regular (iPad schermo intero). NavigationStack viene utilizzato in modalità compatta. Il numero di colonne della griglia (3 vs 2) cambia anche in base alle Size Classes. Tutto si aggiorna automaticamente quando cambia la modalità multitasking.

UISplitViewController: Navigazione a tre colonne

UIKit fornisce UISplitViewController con tre stili: .doubleColumn (barra laterale + dettaglio), .tripleColumn (barra laterale + primaria + dettaglio) e .single. In iPadOS 16+, splitViewController passa automaticamente da uno stile all'altro quando cambia la size class. Lo sviluppatore imposta viewControllers per ogni colonna, UIKit gestisce la visibilità.

Framework e API per iPadOS

iPadOS SDK include tutti i framework iOS e le API disponibili solo su iPad. Di seguito sono elencate le principali capacità specifiche dell'iPad.

Trascinamento

iPadOS supporta il trascinamento tra app e all'interno di un'app. UIDragInteraction e UIDropInteraction consentono di trascinare testo, immagini, file e oggetti personalizzati. Il trascinamento funziona simultaneamente con il multi-touch: l'utente può trascinare più elementi con dita diverse. In SwiftUI vengono utilizzati i modificatori .onDrag e .onDrop.

Scorciatoie da tastiera

Quando si collega una tastiera (Magic Keyboard, Smart Keyboard), UIKeyCommand consente di aggiungere scorciatoie. In iPadOS 17+, le scorciatoie da tastiera vengono visualizzate tenendo premuto Cmd. Apple consiglia di supportare le combinazioni standard: ⌘C (copia), ⌘V (incolla), ⌘F (cerca), ⌘N (nuovo documento).

Monitor esterni

iPadOS 17+ supporta monitor esterni con risoluzione nativa fino a 6K (Pro Display XDR). Un'app può visualizzare contenuti su uno schermo esterno tramite UIWindowScene con un identificatore di sessione separato. Stage Manager consente di posizionare fino a 4 finestre su un monitor esterno con dimensioni ridimensionabili.

Ottimizzazione delle app per iPad

Lo sviluppo per iPadOS richiede un approccio speciale a UI/UX, prestazioni e test. Gli errori perdonabili su iPhone diventano critici su iPad a causa dello schermo più grande e del multitasking.

Prestazioni e memoria

L'iPad utilizza chip della serie M (M1, M2, M4) con memoria unificata fino a 16 GB. Nonostante l'hardware potente, un'app in Split View o Slide Over condivide le risorse con un'altra app. La pressione della memoria è maggiore rispetto all'iPhone. Utilizza compressione delle immagini, caricamento lento delle raccolte e profilazione tramite Instruments Allocations. iPad Pro M4 con 16 GB consente di eseguire app di livello desktop (Final Cut Pro, Logic Pro).

Design Keyboard First

La maggior parte degli utenti iPad utilizza una tastiera esterna. L'interfaccia dovrebbe essere completamente navigabile tramite tastiera: Tab per la navigazione tra i campi, Spazio per attivare un elemento selezionato, Invio per confermare. Aggiungi il supporto per Full Keyboard Access — un'impostazione di sistema che consente di controllare qualsiasi elemento dell'interfaccia con la tastiera.

Test su dispositivi reali

Il simulatore iPad non riproduce completamente il comportamento del multitasking. Testa su un dispositivo reale in diverse modalità: Split View con un'app pesante (Safari con 20 schede), Stage Manager con 4 finestre, Slide Over con cambio rapido di app. Verifica lo scenario: l'utente apre l'app da Slide Over, la trascina in Split View, cambia le dimensioni, la chiude — l'app non dovrebbe bloccarsi.

// Verifica della modalità multitasking corrente su iPadOS
- (void)checkMultitaskingMode:(UIWindowScene *)scene {
    if (scene.traitCollection.userInterfaceIdiom != UIUserInterfaceIdiomPad) {
        return;
    }

    BOOL isFullScreen = (scene.traitCollection.horizontalSizeClass == UIUserInterfaceSizeClassRegular &&
                              scene.traitCollection.verticalSizeClass == UIUserInterfaceSizeClassRegular);

    BOOL isSlideOver = (CGRectGetWidth(scene.coordinateSpace.bounds) == 320.0);

    if (scene.windows.first?.windowScene?.activationConditions.canBecomeFocused == YES) {
        NSLog(@"Stage Manager attivo");
    }

    if (isSlideOver) {
        NSLog(@"Modalità Slide Over");
    } else if (isFullScreen) {
        NSLog(@"Modalità schermo intero");
    } else {
        NSLog(@"Modalità Split View");
    }
}