iPadOS : concepts clés, développement pour iPad et Apple Pencil

Qu'est-ce qu'iPadOS ?

iPadOS est le système d'exploitation d'Apple pour iPad, publié pour la première fois en 2019 en tant que fork d'iOS (version 13). Avant cela, l'iPad utilisait le même iOS que l'iPhone. La séparation d'iPadOS a permis à Apple d'introduire des fonctionnalités spécifiques au grand écran : multitâche, Safari de bureau, glisser-déposer et prise en charge des moniteurs externes.

iPadOS maintient une compatibilité totale avec les applications iOS : toute application iPhone s'exécute sur iPad en mode mise à l'échelle. Cependant, une expérience utilisateur de qualité nécessite une adaptation : utiliser Size Classes, UISplitViewController et la prise en charge des raccourcis clavier. Selon Apple (WWDC 2025), 80 % du temps sur iPad, les utilisateurs le passent dans des versions optimisées pour tablette plutôt que dans des versions mises à l'échelle.

Historique des versions d'iPadOS

iPadOS 13 (2019) a introduit Slide Over et Split View. iPadOS 14 (2020) a ajouté Apple Pencil Scribble et une interface compacte. iPadOS 15 (2021) a introduit Quick Note et des améliorations du multitâche. iPadOS 16 (2022) a apporté Stage Manager et la prise en charge des moniteurs externes. iPadOS 17 (2023) a ajouté des widgets interactifs et la personnalisation de l'écran de verrouillage.

Architecture d'iPadOS et différences avec iOS

iPadOS est basé sur le même noyau XNU et Darwin qu'iOS, mais utilise un shell UIKit modifié adapté à plusieurs fenêtres et des tailles d'écran arbitraires. La différence architecturale clé est la prise en charge d'UIScene, introduite dans iOS 13.

UIScene et cycle de vie des fenêtres

Dans iPadOS, chaque fenêtre (y compris celles en Split View) est une UISceneSession distincte avec son propre cycle de vie. Contrairement à l'iPhone, où une application a une seule UIWindowScene, sur iPad une application peut avoir plusieurs UIScene (plusieurs fenêtres, Slide Over, Stage Manager). SceneDelegate gère l'état de chaque fenêtre indépendamment.

import UIKit
import SwiftUI

/// SceneDelegate pour la prise en charge de plusieurs fenêtres sur 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 }

        // Création de UISplitViewController pour la navigation sur tablette
        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
    }

    // Adaptation lors du changement de taille de fenêtre (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 avec le style .tripleColumn affiche trois colonnes simultanément : barre latérale (navigation), primaire (liste) et détail (contenu). Lors de la transition vers le mode compact (Split View avec une autre application), UIKit réduit automatiquement les colonnes en une pile de navigation. Le développeur ne gère pas ce comportement manuellement — UIKit adapte la disposition via traitCollection.

Différences supplémentaires avec iOS

iPadOS offre : prise en charge du stockage externe via Files (USB-C/Thunderbolt), mode terminal Safari avec inspection d'éléments, raccourcis clavier via UIKeyCommand, gestionnaire de téléchargements système, glisser-déposer entre applications et Picture in Picture avec fenêtre redimensionnable.

Multitâche sur iPad : Split View, Slide Over, Stage Manager

Le multitâche est une fonctionnalité clé d'iPadOS qui le distingue fondamentalement d'iOS. L'utilisateur peut travailler simultanément avec plusieurs applications sur un seul écran. Le développeur doit garantir que l'application fonctionne correctement dans n'importe quel mode multitâche.

Split View

Split View divise l'écran de l'iPad entre deux applications dans un rapport 50/50 ou 33/67. Chaque application reçoit sa propre UISceneSession avec sa propre mémoire et son propre cycle de vie. Lorsque la largeur de l'écran est inférieure à 600 points, UIKit force l'application à passer en taille horizontale compacte. L'application doit gérer correctement ce changement.

Slide Over

Slide Over est une fenêtre flottante au-dessus de l'application active (320 points de large). Une application en Slide Over passe en taille horizontale compacte (.compact). Il est important d'optimiser l'interface pour un écran étroit. En Slide Over, l'application peut être invoquée en glissant depuis le bord droit ou via le dock. L'utilisateur peut faire glisser Slide Over vers Split View ou le fermer en glissant vers la droite.

Stage Manager

Stage Manager (iPadOS 16+, M1 et versions ultérieures) est un gestionnaire de fenêtres qui permet de créer des fenêtres superposées de tailles arbitraires. Jusqu'à 4 fenêtres sont prises en charge sur l'écran de l'iPad et jusqu'à 4 sur un moniteur externe (8 au total). Les applications reçoivent l'événement UISceneWillConnectNotification pour chaque nouvelle fenêtre. Stage Manager modifie les règles du cycle de vie : une fenêtre en arrière-plan n'est pas gelée mais continue de fonctionner avec des ressources limitées.

Apple Pencil et saisie manuscrite

Apple Pencil est le stylet actif d'Apple avec prise en charge de l'inclinaison, de la pression et de la détection hover (iPad Pro M2+). La latence entre le mouvement du stylet et l'affichage de l'encre est de 9 à 20 ms selon le modèle. PencilKit est le framework principal pour intégrer le dessin dans une application.

PencilKit : intégration du dessin

PKCanvasView fournit une surface de dessin prête à l'emploi avec prise en charge de l'encre, du crayon, du marqueur et de la gomme. PKToolPicker est le panneau de sélection d'outils. Le développeur n'a pas besoin d'implémenter le rendu des traits — PencilKit le fait avec accélération matérielle via les shaders Metal. La personnalisation de la couleur, de l'épaisseur et de l'opacité du stylet est disponible.

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)
    }

    // Enregistrement du dessin dans PKDrawing (format binaire)
    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 avec drawingPolicy .anyInput accepte à la fois Apple Pencil et le doigt. PKToolPicker offre à l'utilisateur la sélection d'outils sans avoir à écrire d'interface personnalisée. PKDrawing est stocké dans un format binaire à haute compression — une heure de dessin occupe environ 5 à 10 Mo.

Scribble et reconnaissance de texte

Scribble (iPadOS 14+) permet d'écrire à la main dans n'importe quel UITextField et UITextView. Le système reconnaît l'écriture manuscrite sur l'appareil à l'aide du Neural Engine. Le modèle ML fonctionne avec les alphabets latin et cyrillique. Dans iOS 17+, Scribble prend en charge la correction automatique et la prédiction du mot suivant. Le développeur n'a pas besoin d'ajouter de code — Scribble fonctionne automatiquement avec n'importe quel champ de saisie.

API hover pour Apple Pencil Pro

À partir d'iPadOS 17.4 et d'Apple Pencil Pro, les développeurs obtiennent des événements hover lorsque le stylet s'approche de l'écran (jusqu'à 12 mm). L'événement contient la position, la force et l'azimut. Applications : aperçu du point de contact du pinceau dans les applications de dessin, aperçu de l'outil, retour visuel avant le toucher.

Adaptation de l'interface pour iPad

L'interface adaptative est une exigence obligatoire pour les applications iPad. L'iPad fonctionne avec différentes tailles d'écran (8,3"–13") et modes multitâches. UIKit fournit Size Classes (horizontal : .regular/.compact, vertical : .regular/.compact) et UISplitViewController pour l'adaptation automatique.

Size Classes et traitCollection

Size Classes sont une abstraction qui définit l'espace disponible. Sur iPad en mode plein écran, les deux axes sont .regular. En Split View (50 %), la classe horizontale peut devenir .compact sur iPad mini ou iPad Air. Toutes les dispositions populaires construites avec Auto Layout et UICollectionViewCompositionalLayout s'adaptent automatiquement. L'adaptation personnalisée se fait en remplaçant traitCollectionDidChange.

import SwiftUI

/// Disposition adaptative pour iPad utilisant Size Classes
struct AdaptiveContentView: View {
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
    @Environment(\.verticalSizeClass) private var verticalSizeClass

    var body: some View {
        if horizontalSizeClass == .regular && verticalSizeClass == .regular {
            // Mode tablette : barre latérale + contenu
            NavigationSplitView {
                SidebarView()
            } detail: {
                ContentGridView()
            }
        } else {
            // Mode compact : navigation en pile
            NavigationStack {
                ContentGridView()
            }
        }
    }
}

/// Exemple de grille adaptative : 3 colonnes sur iPad, 2 sur 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()
        }
    }
}

Dans l'exemple, NavigationSplitView est utilisé uniquement lorsque horizontalSizeClass == .regular (iPad plein écran). NavigationStack est utilisé en mode compact. Le nombre de colonnes de la grille (3 vs 2) change également en fonction des Size Classes. Tout se met à jour automatiquement lorsque le mode multitâche change.

UISplitViewController : navigation à trois colonnes

UIKit fournit UISplitViewController avec trois styles : .doubleColumn (barre latérale + détail), .tripleColumn (barre latérale + primaire + détail) et .single. Dans iPadOS 16+, splitViewController bascule automatiquement entre les styles lorsque le size class change. Le développeur définit viewControllers pour chaque colonne, UIKit gère la visibilité.

Frameworks et API pour iPadOS

iPadOS SDK inclut tous les frameworks iOS ainsi que les API disponibles uniquement sur iPad. Voici les principales capacités spécifiques à l'iPad.

Glisser-déposer

iPadOS prend en charge le glisser-déposer entre les applications et au sein d'une application. UIDragInteraction et UIDropInteraction permettent de faire glisser du texte, des images, des fichiers et des objets personnalisés. Le glisser-déposer fonctionne simultanément avec le multi-touch : l'utilisateur peut faire glisser plusieurs éléments avec différents doigts. Dans SwiftUI, les modificateurs .onDrag et .onDrop sont utilisés.

Raccourcis clavier

Lorsqu'un clavier est connecté (Magic Keyboard, Smart Keyboard), UIKeyCommand permet d'ajouter des raccourcis. Dans iPadOS 17+, les raccourcis clavier s'affichent en maintenant Cmd enfoncé. Apple recommande de prendre en charge les combinaisons standard : ⌘C (copier), ⌘V (coller), ⌘F (rechercher), ⌘N (nouveau document).

Moniteurs externes

iPadOS 17+ prend en charge les moniteurs externes avec une résolution native jusqu'à 6K (Pro Display XDR). Une application peut afficher du contenu sur un écran externe via UIWindowScene avec un identifiant de session distinct. Stage Manager permet de placer jusqu'à 4 fenêtres sur un moniteur externe avec des dimensions redimensionnables.

Optimisation des applications pour iPad

Le développement pour iPadOS nécessite une approche spéciale en matière d'UI/UX, de performances et de tests. Les erreurs pardonnables sur iPhone deviennent critiques sur iPad en raison du grand écran et du multitâche.

Performances et mémoire

L'iPad utilise des puces de la série M (M1, M2, M4) avec une mémoire unifiée allant jusqu'à 16 Go. Malgré le matériel puissant, une application en Split View ou Slide Over partage les ressources avec une autre application. La pression mémoire est plus élevée que sur iPhone. Utilisez la compression d'images, le chargement différé des collections et le profilage via Instruments Allocations. L'iPad Pro M4 avec 16 Go permet d'exécuter des applications de niveau bureau (Final Cut Pro, Logic Pro).

Conception Keyboard First

La plupart des utilisateurs d'iPad utilisent un clavier externe. L'interface doit être entièrement navigable au clavier : Tab pour la navigation entre les champs, Espace pour activer un élément sélectionné, Entrée pour confirmer. Ajoutez la prise en charge de Full Keyboard Access — un paramètre système qui permet de contrôler n'importe quel élément d'interface avec le clavier.

Tests sur des appareils réels

Le simulateur iPad ne reproduit pas entièrement le comportement multitâche. Testez sur un appareil réel dans différents modes : Split View avec une application lourde (Safari avec 20 onglets), Stage Manager avec 4 fenêtres, Slide Over avec changement rapide d'applications. Vérifiez le scénario : l'utilisateur ouvre l'application depuis Slide Over, la fait glisser vers Split View, change la taille, la ferme — l'application ne doit pas planter.

// Vérification du mode multitâche actuel sur 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 actif");
    }

    if (isSlideOver) {
        NSLog(@"Mode Slide Over");
    } else if (isFullScreen) {
        NSLog(@"Mode plein écran");
    } else {
        NSLog(@"Mode Split View");
    }
}