iPadOS: kluczowe pojęcia, programowanie pod iPada i Apple Pencil

Czym jest iPadOS?

iPadOS — system operacyjny Apple dla iPadów, po raz pierwszy wydany w 2019 roku jako odgałęzienie iOS (wersja 13). Wcześniej iPad używał tego samego iOS co iPhone. Wydzielenie iPadOS pozwoliło Apple wprowadzić funkcje specyficzne dla dużego ekranu: wielozadaniowość, desktopowy Safari, Drag & Drop i obsługę zewnętrznych monitorów.

iPadOS zachowuje pełną kompatybilność z aplikacjami iOS: każda aplikacja iPhone'a uruchamia się na iPadzie w trybie skalowania. Jednak dla jakościowego doświadczenia użytkownika wymagana jest adaptacja: użycie Size Classes, UISplitViewController i obsługa skrótów klawiaturowych. Według Apple (WWDC 2025), 80% czasu na iPadzie użytkownicy spędzają w tabletowych, a nie skalowanych wersjach aplikacji.

Historia wersji iPadOS

iPadOS 13 (2019) wprowadził Slide Over i Split View. iPadOS 14 (2020) dodał Apple Pencil Scribble i kompaktowy UI. iPadOS 15 (2021) wprowadził Quick Note i ulepszenia multitaskingu. iPadOS 16 (2022) przedstawił Stage Manager i obsługę zewnętrznych monitorów. iPadOS 17 (2023) dodał interaktywne widżety i personalizację Lock Screen.

Architektura iPadOS i różnica od iOS

iPadOS bazuje na tym samym jądrze XNU i Darwin co iOS, ale używa zmodyfikowanej powłoki UIKit, dostosowanej do pracy z wieloma oknami i dowolnymi rozmiarami ekranu. Kluczowa różnica architektoniczna — obsługa UIScene, wprowadzona w iOS 13.

UIScene i cykl życia okien

W iPadOS każde okno (w tym w Split View) to osobna UISceneSession z własnym cyklem życia. W przeciwieństwie do iPhone'a, gdzie jedna aplikacja ma jeden UIWindowScene, na iPadzie jedna aplikacja może mieć wiele UIScene (wiele okien, Slide Over, Stage Manager). SceneDelegate zarządza stanem każdego okna niezależnie.

import UIKit
import SwiftUI

/// SceneDelegate do obsługi wielu okien na 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 }

        // Tworzymy UISplitViewController dla nawigacji tabletowej
        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
    }

    // Adaptacja przy zmianie rozmiaru okna (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 ze stylem .tripleColumn wyświetla trzy kolumny jednocześnie: sidebar (nawigacja), primary (lista) i detail (treść). Przy przejściu w tryb kompaktowy (Split View z inną aplikacją) UIKit automatycznie zwija kolumny w stos nawigacyjny. Deweloper nie zarządza tym zachowaniem ręcznie — UIKit dostosowuje układ przez traitCollection.

Dodatkowe różnice od iOS

W iPadOS dostępne są: obsługa zewnętrznych dysków przez Files (USB-C/Thunderbolt), tryb terminalowy Safari z inspekcją elementów, skróty klawiaturowe przez UIKeyCommand, systemowy menedżer pobierania, Drag & Drop między aplikacjami i Picture in Picture ze zmiennym rozmiarem okna.

Multitasking na iPadzie: Split View, Slide Over, Stage Manager

Multitasking — kluczowa cecha iPadOS, zasadniczo odróżniająca go od iOS. Użytkownik może jednocześnie pracować z kilkoma aplikacjami na jednym ekranie. Deweloper musi zagwarantować, że aplikacja działa poprawnie w każdym trybie wielozadaniowości.

Split View

Split View dzieli ekran iPada między dwie aplikacje w proporcji 50/50 lub 33/67. Każda aplikacja otrzymuje własną UISceneSession z własną pamięcią i cyklem życia. Przy szerokości ekranu mniejszej niż 600 punktów UIKit przymusowo przełącza aplikację w kompaktowy poziomy size class. Aplikacja musi poprawnie obsługiwać tę zmianę.

Slide Over

Slide Over — pływające okno nad aktywną aplikacją (szerokość 320 punktów). Aplikacja w Slide Over przechodzi w kompaktowy poziomy size class (.compact). Ważne jest optymalizowanie UI dla wąskiego ekranu. W Slide Over aplikacja może być wywołana przesunięciem od prawej krawędzi lub przez dock. Użytkownik może przeciągnąć Slide Over do Split View lub zamknąć przesunięciem w prawo.

Stage Manager

Stage Manager (iPadOS 16+, M1 i nowsze) — menedżer okien, pozwalający tworzyć nakładające się okna o dowolnych rozmiarach. Obsługuje do 4 okien na ekranie iPada i do 4 na zewnętrznym monitorze (łącznie 8). Aplikacje otrzymują zdarzenie UISceneWillConnectNotification dla każdego nowego okna. Stage Manager zmienia zasady cyklu życia: okno w tle nie jest zamrażane, ale kontynuuje pracę z ograniczonymi zasobami.

Apple Pencil i wprowadzanie odręczne

Apple Pencil — aktywny rysik Apple z obsługą nachylenia, nacisku i wykrywania zbliżenia (iPad Pro M2+). Opóźnienie między ruchem rysika a wyświetleniem atramentu wynosi 9–20 ms w zależności od modelu. PencilKit — główny framework do integracji rysowania w aplikacji.

PencilKit: integracja rysowania

PKCanvasView zapewnia gotową powierzchnię do rysowania z obsługą tuszu, ołówka, markera i gumki. PKToolPicker — panel wyboru narzędzi. Deweloper nie musi implementować renderowania pociągnięć — PencilKit robi to sprzętowo z shaderami Metal. Dostępne są ustawienia koloru, grubości i przezroczystości rysika.

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

    // Zapis rysunku w PKDrawing (format binarny)
    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 z drawingPolicy .anyInput przyjmuje zarówno Apple Pencil, jak i palec. PKToolPicker daje użytkownikowi wybór narzędzi bez potrzeby pisania własnego UI. PKDrawing przechowywane jest w formacie binarnym z wysokim stopniem kompresji — godzina rysowania zajmuje około 5–10 MB.

Scribble i rozpoznawanie tekstu

Scribble (iPadOS 14+) pozwala pisać odręcznie w dowolnym UITextField i UITextView. System rozpoznaje pismo odręczne na urządzeniu z wykorzystaniem Neural Engine. Model ML działa z alfabetem łacińskim i cyrylicą. W iOS 17+ Scribble obsługuje autokorektę i przewidywanie następnego słowa. Deweloper nie musi dodawać kodu — Scribble działa automatycznie przy polu wprowadzania.

Hover API dla Apple Pencil Pro

Od iPadOS 17.4 i Apple Pencil Pro deweloperzy otrzymują zdarzenia zbliżenia przy zbliżeniu rysika do ekranu (do 12 mm). Zdarzenie zawiera pozycję, siłę nacisku i azymut. Zastosowanie: podgląd punktu dotyku pędzla w programach do rysowania, podgląd narzędzia, wizualne sprzężenie zwrotne przed dotknięciem.

Adaptacja interfejsu pod iPada

Interfejs adaptacyjny — obowiązkowy wymóg dla aplikacji na iPada. iPad działa w różnych rozmiarach ekranu (8,3″–13″) i trybach wielozadaniowości. UIKit udostępnia Size Classes (horizontal: .regular/.compact, vertical: .regular/.compact) i UISplitViewController do automatycznej adaptacji.

Size Classes i traitCollection

Size Classes — abstrakcja określająca dostępną przestrzeń. Na iPadzie w trybie pełnoekranowym obie osie — .regular. W Split View (50%) pozioma klasa może stać się .compact na iPadzie mini lub iPadzie Air. Wszystkie popularne układy zbudowane na Auto Layout i UICollectionViewCompositionalLayout adaptują się automatycznie. Niestandardowa adaptacja wykonywana jest przez nadpisanie traitCollectionDidChange.

import SwiftUI

/// Adaptacyjny layout dla iPada z użyciem Size Classes
struct AdaptiveContentView: View {
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
    @Environment(\.verticalSizeClass) private var verticalSizeClass

    var body: some View {
        if horizontalSizeClass == .regular && verticalSizeClass == .regular {
            // Tryb tabletowy: sidebar + content
            NavigationSplitView {
                SidebarView()
            } detail: {
                ContentGridView()
            }
        } else {
            // Tryb kompaktowy: nawigacja stosowa
            NavigationStack {
                ContentGridView()
            }
        }
    }
}

/// Przykład adaptacyjnej siatki: 3 kolumny na iPadzie, 2 na iPhonie
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()
        }
    }
}

W przykładzie NavigationSplitView jest używany tylko gdy horizontalSizeClass == .regular (pełnoekranowy iPad). NavigationStack jest stosowany w trybie kompaktowym. Liczba kolumn siatki (3 vs 2) również zmienia się w zależności od Size Classes. Wszystko aktualizuje się automatycznie przy zmianie trybu wielozadaniowości.

UISplitViewController: nawigacja trójkolumnowa

UIKit udostępnia UISplitViewController z trzema stylami: .doubleColumn (sidebar + detail), .tripleColumn (sidebar + primary + detail) i .single. W iPadOS 16+ splitViewController automatycznie przełącza się między stylami przy zmianie size class. Deweloper ustawia viewControllers dla każdej kolumny, UIKit zarządza widocznością.

Frameworki i API dla iPadOS

iPadOS SDK zawiera wszystkie frameworki iOS, a także API dostępne tylko na iPadzie. Poniżej przedstawiono kluczowe możliwości specyficzne dla iPada.

Drag & Drop

iPadOS obsługuje Drag & Drop między aplikacjami i wewnątrz aplikacji. UIDragInteraction i UIDropInteraction pozwalają przeciągać tekst, obrazy, pliki i niestandardowe obiekty. Drag & Drop działa jednocześnie z Multi-Touch: użytkownik może przeciągać wiele elementów różnymi palcami. W SwiftUI używane są modyfikatory .onDrag i .onDrop.

Skróty klawiaturowe

Po podłączeniu klawiatury (Magic Keyboard, Smart Keyboard) UIKeyCommand pozwala dodać skróty klawiszowe. W iPadOS 17+ skróty klawiaturowe są wyświetlane przy długim przytrzymaniu Cmd. Apple zaleca obsługę standardowych kombinacji: ⌘C (kopiuj), ⌘V (wklej), ⌘F (szukaj), ⌘N (nowy dokument).

Zewnętrzne monitory

iPadOS 17+ obsługuje zewnętrzne monitory z natywną rozdzielczością do 6K (Pro Display XDR). Aplikacja może wyświetlać treść na zewnętrznym ekranie przez UIWindowScene z osobnym identyfikatorem sesji. Stage Manager pozwala umieścić do 4 okien na zewnętrznym monitorze o zmiennych rozmiarach.

Optymalizacja aplikacji pod iPada

Programowanie pod iPadOS wymaga szczególnego podejścia do UI/UX, wydajności i testowania. Błędy wybaczalne na iPhonie stają się krytyczne na iPadzie z powodu większego ekranu i wielozadaniowości.

Wydajność i pamięć

iPad używa chipów serii M (M1, M2, M4) z ujednoliconą pamięcią do 16 GB. Pomimo potężnego sprzętu, aplikacja w Split View lub Slide Over dzieli zasoby z inną aplikacją. Presja pamięci jest wyższa niż na iPhonie. Używaj kompresji obrazów, leniwego ładowania kolekcji i profilowania przez Instruments Allocations. iPad Pro M4 z 16 GB pozwala uruchamiać aplikacje na poziomie desktopu (Final Cut Pro, Logic Pro).

Projektowanie Keyboard First

Większość użytkowników iPada używa zewnętrznej klawiatury. Interfejs powinien być w pełni sterowalny z klawiatury: Tab do nawigacji po polach, Space do aktywacji wybranego elementu, Enter do potwierdzenia. Dodaj obsługę Full Keyboard Access — ustawienia systemowego pozwalającego sterować dowolnym elementem UI z klawiatury.

Testowanie na rzeczywistych urządzeniach

Symulator iPada nie w pełni odtwarza zachowanie wielozadaniowości. Testuj na rzeczywistym urządzeniu w różnych trybach: Split View z ciężką aplikacją (Safari z 20 zakładkami), Stage Manager z 4 oknami, Slide Over z szybką zmianą aplikacji. Sprawdź scenariusz: użytkownik otwiera aplikację z Slide Over, przeciąga ją do Split View, zmienia rozmiar, zamyka — aplikacja nie powinna się crashować.

// Sprawdzanie bieżącego trybu wielozadaniowości na 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 aktywny");
    }

    if (isSlideOver) {
        NSLog(@"Tryb Slide Over");
    } else if (isFullScreen) {
        NSLog(@"Tryb pełnoekranowy");
    } else {
        NSLog(@"Tryb Split View");
    }
}