iPadOS: nyckelbegrepp, utveckling för iPad och Apple Pencil

Vad är iPadOS?

iPadOS — Apples operativsystem för iPad, första gången släppt 2019 som en gren av iOS (version 13). Innan dess använde iPad samma iOS som iPhone. Avskiljandet av iPadOS gjorde det möjligt för Apple att implementera funktioner specifika för stor skärm: multitasking, skrivbords Safari, Drag & Drop och stöd för externa monitorer.

iPadOS behåller full kompatibilitet med iOS-appar: alla iPhone-appar körs på iPad i skalläge. För en kvalitativ användarupplevelse krävs dock anpassning: användning av Size Classes, UISplitViewController och stöd för kortkommandon. Enligt Apple (WWDC 2025) tillbringar användare 80 % av tiden på iPad i surfplatteversioner, inte i skalade versioner.

Historik över iPadOS-versioner

iPadOS 13 (2019) introducerade Slide Over och Split View. iPadOS 14 (2020) lade till Apple Pencil Scribble och kompakt UI. iPadOS 15 (2021) introducerade Quick Note och förbättringar av multitasking. iPadOS 16 (2022) presenterade Stage Manager och stöd för externa monitorer. iPadOS 17 (2023) lade till interaktiva widgetar och Lock Screen-anpassning.

Arkitektur för iPadOS och skillnad från iOS

iPadOS är baserat på samma XNU-kärna och Darwin som iOS, men använder ett modifierat UIKit-skal anpassat för arbete med flera fönster och godtyckliga skärmstorlekar. Den viktigaste arkitektoniska skillnaden — stöd för UIScene, introducerat i iOS 13.

UIScene och fönsterlivscykel

I iPadOS är varje fönster (inklusive i Split View) en separat UISceneSession med egen livscykel. Till skillnad från iPhone, där en app har en UIWindowScene, kan en app på iPad ha flera UIScene (flera fönster, Slide Over, Stage Manager). SceneDelegate hanterar varje fönsters tillstånd oberoende.

import UIKit
import SwiftUI

/// SceneDelegate för stöd av flera fönster på 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 }

        // Skapa UISplitViewController för surfplattenavigering
        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
    }

    // Anpassning vid ändring av fönsterstorlek (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 med .tripleColumn-stil visar tre kolumner samtidigt: sidebar (navigering), primary (lista) och detail (innehåll). Vid övergång till kompakt läge (Split View med en annan app) viker UIKit automatiskt ihop kolumnerna till en navigeringsstack. Utvecklaren hanterar inte detta beteende manuellt — UIKit anpassar layouten via traitCollection.

Ytterligare skillnader från iOS

I iPadOS finns: stöd för externa enheter via Files (USB-C/Thunderbolt), terminalläge i Safari med elementinspektion, kortkommandon via UIKeyCommand, systemets nedladdningshanterare, Drag & Drop mellan appar och Picture in Picture med justerbar fönsterstorlek.

Multitasking på iPad: Split View, Slide Over, Stage Manager

Multitasking — den viktigaste funktionen i iPadOS som skiljer det fundamentalt från iOS. Användaren kan arbeta samtidigt med flera appar på en skärm. Utvecklaren måste garantera att appen fungerar korrekt i vilket multitasking-läge som helst.

Split View

Split View delar iPad-skärmen mellan två appar i förhållandet 50/50 eller 33/67. Varje app får en egen UISceneSession med eget minne och livscykel. Vid skärmbredd mindre än 600 punkter tvingar UIKit appen till kompakt horisontell size class. Appen måste hantera denna ändring korrekt.

Slide Over

Slide Over — ett flytande fönster ovanför den aktiva appen (bredd 320 punkter). Appen i Slide Over växlar till kompakt horisontell size class (.compact). Det är viktigt att optimera UI för smal skärm. I Slide Over kan appen anropas genom att svepa från högerkanten eller via docken. Användaren kan dra Slide Over till Split View eller stänga det genom att svepa åt höger.

Stage Manager

Stage Manager (iPadOS 16+, M1 och nyare) — en fönsterhanterare som gör det möjligt att skapa överlappande fönster av godtycklig storlek. Stöder upp till 4 fönster på iPad-skärmen och upp till 4 på extern monitor (totalt 8). Appar får UISceneWillConnectNotification-händelsen för varje nytt fönster. Stage Manager ändrar livscykelreglerna: ett fönster i bakgrunden fryses inte utan fortsätter att arbeta med begränsade resurser.

Apple Pencil och handskriftsinmatning

Apple Pencil — aktiv penna från Apple med stöd för lutning, tryck och hover-detektion (iPad Pro M2+). Fördröjningen mellan pennrörelse och bläckvisning är 9–20 ms beroende på modell. PencilKit — det huvudsakliga ramverket för att integrera ritning i en app.

PencilKit: ritningsintegration

PKCanvasView ger en färdig rityta med stöd för bläck, penna, markeringspenna och suddgummi. PKToolPicker — panel för verktygsval. Utvecklaren behöver inte implementera rendering av streck — PencilKit gör det hårdvarumässigt med Metal-shaders. Inställning av färg, tjocklek och pennans genomskinlighet finns tillgängligt.

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

    // Spara ritning i PKDrawing (binärt format)
    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 med drawingPolicy .anyInput accepterar både Apple Pencil och finger. PKToolPicker ger användaren val av verktyg utan att behöva skriva ett eget UI. PKDrawing lagras i binärt format med hög kompressionsgrad — en timmes ritning tar cirka 5–10 MB.

Scribble och textigenkänning

Scribble (iPadOS 14+) möjliggör handskriftsinmatning i alla UITextField och UITextView. Systemet känner igen handskrift på enheten med Neural Engine. ML-modellen fungerar med latinska och kyrilliska alfabetet. I iOS 17+ stöder Scribble automatisk korrigering och prediktion av nästa ord. Utvecklaren behöver inte lägga till kod — Scribble fungerar automatiskt när ett inmatningsfält finns.

Hover API för Apple Pencil Pro

Från iPadOS 17.4 och Apple Pencil Pro får utvecklare hover-händelser när pennan närmar sig skärmen (upp till 12 mm). Händelsen innehåller position, tryckkraft och azimut. Tillämpning: förhandsvisning av penselns kontaktpunkt i ritprogram, verktygsförhandsvisning, visuell återkoppling före beröring.

Anpassning av gränssnitt för iPad

Adaptivt gränssnitt — ett obligatoriskt krav för iPad-appar. iPad fungerar i olika skärmstorlekar (8.3″–13″) och multitasking-lägen. UIKit tillhandahåller Size Classes (horizontal: .regular/.compact, vertical: .regular/.compact) och UISplitViewController för automatisk anpassning.

Size Classes och traitCollection

Size Classes — en abstraktion som bestämmer tillgängligt utrymme. På iPad i helskärmsläge är båda axlarna .regular. I Split View (50 %) kan den horisontella klassen bli .compact på iPad mini eller iPad Air. Alla populära layouter byggda på Auto Layout och UICollectionViewCompositionalLayout anpassas automatiskt. Anpassad anpassning görs genom att åsidosätta traitCollectionDidChange.

import SwiftUI

/// Adaptiv layout för iPad med Size Classes
struct AdaptiveContentView: View {
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
    @Environment(\.verticalSizeClass) private var verticalSizeClass

    var body: some View {
        if horizontalSizeClass == .regular && verticalSizeClass == .regular {
            // Surfplatteläge: sidebar + content
            NavigationSplitView {
                SidebarView()
            } detail: {
                ContentGridView()
            }
        } else {
            // Kompakt läge: stacknavigering
            NavigationStack {
                ContentGridView()
            }
        }
    }
}

/// Exempel på adaptivt rutnät: 3 kolumner på iPad, 2 på 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()
        }
    }
}

I exemplet används NavigationSplitView endast när horizontalSizeClass == .regular (iPad helskärm). NavigationStack tillämpas i kompakt läge. Antalet kolumner i rutnätet (3 vs 2) ändras också beroende på Size Classes. Allt uppdateras automatiskt när multitasking-läget ändras.

UISplitViewController: trespaltig navigering

UIKit tillhandahåller UISplitViewController med tre stilar: .doubleColumn (sidebar + detail), .tripleColumn (sidebar + primary + detail) och .single. I iPadOS 16+ växlar splitViewController automatiskt mellan stilar när size class ändras. Utvecklaren ställer in viewControllers för varje kolumn, UIKit hanterar synlighet.

Ramverk och API för iPadOS

iPadOS SDK innehåller alla iOS-ramverk, samt API:er som endast är tillgängliga på iPad. Nedan visas de viktigaste iPad-specifika funktionerna.

Drag & Drop

iPadOS stöder Drag & Drop mellan appar och inom en app. UIDragInteraction och UIDropInteraction gör det möjligt att dra text, bilder, filer och anpassade objekt. Drag & Drop fungerar samtidigt med Multi-Touch: användaren kan dra flera element med olika fingrar. I SwiftUI används modifierarna .onDrag och .onDrop.

Kortkommandon

När ett tangentbord ansluts (Magic Keyboard, Smart Keyboard) gör UIKeyCommand det möjligt att lägga till kortkommandon. I iPadOS 17+ visas kortkommandon vid lång tryckning på Cmd. Apple rekommenderar att stödja standardkombinationer: ⌘C (kopiera), ⌘V (klistra in), ⌘F (sök), ⌘N (nytt dokument).

Externa monitorer

iPadOS 17+ stöder externa monitorer med ursprunglig upplösning upp till 6K (Pro Display XDR). Appen kan visa innehåll på den externa skärmen via UIWindowScene med separat sessions-ID. Stage Manager gör det möjligt att placera upp till 4 fönster med justerbar storlek på den externa monitorn.

Optimering av appar för iPad

Utveckling för iPadOS kräver ett särskilt angreppssätt för UI/UX, prestanda och testning. Misstag som är förlåtliga på iPhone blir kritiska på iPad på grund av den större skärmen och multitasking.

Prestanda och minne

iPad använder M-seriechip (M1, M2, M4) med enhetligt minne upp till 16 GB. Trots kraftfull hårdvara delar appen i Split View eller Slide Over resurser med en annan app. Minrestryck är högre än på iPhone. Använd bildkomprimering, lat inläsning av samlingar och profilering via Instruments Allocations. iPad Pro M4 med 16 GB gör det möjligt att köra applikationer på skrivbordsnivå (Final Cut Pro, Logic Pro).

Keyboard First-design

De flesta iPad-användare använder externt tangentbord. Gränssnittet måste vara helt styrbart från tangentbordet: Tab för navigering mellan fält, Space för att aktivera markerat element, Enter för bekräftelse. Lägg till stöd för Full Keyboard Access — systeminställningen som gör det möjligt att styra alla UI-element från tangentbordet.

Testning på verkliga enheter

iPad-simulatorn återger inte fullt ut multitasking-beteendet. Testa på en verklig enhet i olika lägen: Split View med tung app (Safari med 20 flikar), Stage Manager med 4 fönster, Slide Over med snabb växling av appar. Kontrollera scenariot: användaren öppnar appen från Slide Over, drar den till Split View, ändrar storlek, stänger — appen får inte krascha.

// Kontroll av aktuellt multitasking-läge på 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 aktivt");
    }

    if (isSlideOver) {
        NSLog(@"Slide Over-läge");
    } else if (isFullScreen) {
        NSLog(@"Helskärmsläge");
    } else {
        NSLog(@"Split View-läge");
    }
}