iPadOS: conceitos-chave, desenvolvimento para iPad e Apple Pencil

O que é iPadOS?

iPadOS é o sistema operacional da Apple para iPad, lançado pela primeira vez em 2019 como uma bifurcação do iOS (versão 13). Antes disso, o iPad usava o mesmo iOS do iPhone. A separação do iPadOS permitiu que a Apple introduzisse recursos específicos para a tela grande: multitarefa, Safari de desktop, Drag & Drop e suporte a monitores externos.

iPadOS mantém compatibilidade total com aplicativos iOS: qualquer aplicativo do iPhone é executado no iPad em modo de escala. No entanto, uma experiência de usuário de qualidade requer adaptação: usar Size Classes, UISplitViewController e suporte a atalhos de teclado. De acordo com a Apple (WWDC 2025), 80% do tempo no iPad os usuários passam em versões otimizadas para tablet, não em versões escaladas.

Histórico de versões do iPadOS

iPadOS 13 (2019) introduziu Slide Over e Split View. iPadOS 14 (2020) adicionou Apple Pencil Scribble e interface compacta. iPadOS 15 (2021) introduziu Quick Note e melhorias na multitarefa. iPadOS 16 (2022) trouxe Stage Manager e suporte a monitores externos. iPadOS 17 (2023) adicionou widgets interativos e personalização da Lock Screen.

Arquitetura do iPadOS e diferenças do iOS

iPadOS é baseado no mesmo kernel XNU e Darwin do iOS, mas usa um shell UIKit modificado adaptado para múltiplas janelas e tamanhos de tela arbitrários. A diferença arquitetural chave é o suporte a UIScene, introduzido no iOS 13.

UIScene e ciclo de vida de janelas

No iPadOS, cada janela (incluindo as do Split View) é uma UISceneSession separada com seu próprio ciclo de vida. Diferente do iPhone, onde um aplicativo tem uma única UIWindowScene, no iPad um aplicativo pode ter várias UIScene (várias janelas, Slide Over, Stage Manager). SceneDelegate gerencia o estado de cada janela independentemente.

import UIKit
import SwiftUI

/// SceneDelegate para suporte a múltiplas janelas no 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 }

        // Criando UISplitViewController para navegação em 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
    }

    // Adaptação ao mudar o tamanho da janela (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 com estilo .tripleColumn exibe três colunas simultaneamente: sidebar (navegação), primary (lista) e detail (conteúdo). Ao transicionar para o modo compacto (Split View com outro aplicativo), UIKit colapsa automaticamente as colunas em uma pilha de navegação. O desenvolvedor não gerencia esse comportamento manualmente — UIKit adapta o layout através de traitCollection.

Diferenças adicionais do iOS

iPadOS oferece: suporte a armazenamento externo via Files (USB-C/Thunderbolt), modo terminal do Safari com inspeção de elementos, atalhos de teclado via UIKeyCommand, gerenciador de downloads do sistema, Drag & Drop entre aplicativos e Picture in Picture com janela redimensionável.

Multitarefa no iPad: Split View, Slide Over, Stage Manager

Multitarefa é um recurso chave do iPadOS que o diferencia fundamentalmente do iOS. O usuário pode trabalhar simultaneamente com vários aplicativos em uma única tela. O desenvolvedor deve garantir que o aplicativo funcione corretamente em qualquer modo de multitarefa.

Split View

Split View divide a tela do iPad entre dois aplicativos em uma proporção de 50/50 ou 33/67. Cada aplicativo recebe sua própria UISceneSession com sua própria memória e ciclo de vida. Quando a largura da tela é inferior a 600 pontos, UIKit força o aplicativo a um tamanho horizontal compacto. O aplicativo deve lidar com essa mudança corretamente.

Slide Over

Slide Over é uma janela flutuante sobre o aplicativo ativo (320 pontos de largura). Um aplicativo no Slide Over muda para um tamanho horizontal compacto (.compact). É importante otimizar a UI para uma tela estreita. No Slide Over, o aplicativo pode ser invocado deslizando da borda direita ou através do dock. O usuário pode arrastar o Slide Over para o Split View ou fechá-lo deslizando para a direita.

Stage Manager

Stage Manager (iPadOS 16+, M1 e posteriores) é um gerenciador de janelas que permite criar janelas sobrepostas de tamanhos arbitrários. São suportadas até 4 janelas na tela do iPad e até 4 em um monitor externo (8 no total). Os aplicativos recebem o evento UISceneWillConnectNotification para cada nova janela. Stage Manager muda as regras do ciclo de vida: uma janela em segundo plano não é congelada, mas continua funcionando com recursos limitados.

Apple Pencil e entrada manuscrita

Apple Pencil é a caneta ativa da Apple com suporte a inclinação, pressão e detecção hover (iPad Pro M2+). A latência entre o movimento da caneta e a exibição da tinta é de 9–20 ms dependendo do modelo. PencilKit é o framework principal para integrar desenho em um aplicativo.

PencilKit: Integração de desenho

PKCanvasView fornece uma superfície de desenho pronta com suporte a tinta, lápis, marcador e borracha. PKToolPicker é o painel de seleção de ferramentas. O desenvolvedor não precisa implementar renderização de traços — PencilKit faz isso acelerado por hardware com shaders Metal. Personalização de cor, espessura e opacidade da caneta estão disponíveis.

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

    // Salvando desenho em PKDrawing (formato binário)
    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 com drawingPolicy .anyInput aceita tanto Apple Pencil quanto dedo. PKToolPicker dá ao usuário seleção de ferramentas sem precisar escrever UI personalizada. PKDrawing é armazenado em formato binário com alta compressão — uma hora de desenho ocupa cerca de 5–10 MB.

Scribble e reconhecimento de texto

Scribble (iPadOS 14+) permite escrever à mão em qualquer UITextField e UITextView. O sistema reconhece escrita à mão no dispositivo usando Neural Engine. O modelo ML funciona com alfabeto latino e cirílico. No iOS 17+, Scribble suporta autocorreção e previsão da próxima palavra. O desenvolvedor não precisa adicionar código — Scribble funciona automaticamente com qualquer campo de entrada.

Hover API para Apple Pencil Pro

A partir do iPadOS 17.4 e Apple Pencil Pro, os desenvolvedores obtêm eventos hover quando a caneta se aproxima da tela (até 12 mm). O evento contém posição, força e azimute. Aplicações: pré-visualização do ponto de contato do pincel em aplicativos de desenho, pré-visualização de ferramenta, feedback visual antes do toque.

Adaptação da interface para iPad

Interface adaptativa é um requisito obrigatório para aplicativos iPad. O iPad opera em diferentes tamanhos de tela (8.3"–13") e modos de multitarefa. UIKit fornece Size Classes (horizontal: .regular/.compact, vertical: .regular/.compact) e UISplitViewController para adaptação automática.

Size Classes e traitCollection

Size Classes são uma abstração que define o espaço disponível. No iPad em modo tela cheia, ambos os eixos são .regular. No Split View (50%), a classe horizontal pode se tornar .compact no iPad mini ou iPad Air. Todos os layouts populares construídos com Auto Layout e UICollectionViewCompositionalLayout se adaptam automaticamente. A adaptação personalizada é feita sobrescrevendo traitCollectionDidChange.

import SwiftUI

/// Layout adaptativo para iPad usando Size Classes
struct AdaptiveContentView: View {
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
    @Environment(\.verticalSizeClass) private var verticalSizeClass

    var body: some View {
        if horizontalSizeClass == .regular && verticalSizeClass == .regular {
            // Modo tablet: sidebar + content
            NavigationSplitView {
                SidebarView()
            } detail: {
                ContentGridView()
            }
        } else {
            // Modo compacto: navegação em pilha
            NavigationStack {
                ContentGridView()
            }
        }
    }
}

/// Exemplo de grade adaptativa: 3 colunas no iPad, 2 no 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()
        }
    }
}

No exemplo, NavigationSplitView é usado apenas quando horizontalSizeClass == .regular (iPad tela cheia). NavigationStack é usado no modo compacto. O número de colunas da grade (3 vs 2) também muda dependendo das Size Classes. Tudo atualiza automaticamente quando o modo multitarefa muda.

UISplitViewController: Navegação de três colunas

UIKit fornece UISplitViewController com três estilos: .doubleColumn (sidebar + detail), .tripleColumn (sidebar + primary + detail) e .single. No iPadOS 16+, splitViewController alterna automaticamente entre estilos quando o size class muda. O desenvolvedor define viewControllers para cada coluna, UIKit gerencia a visibilidade.

Frameworks e APIs para iPadOS

iPadOS SDK inclui todos os frameworks do iOS, bem como APIs disponíveis apenas no iPad. Abaixo estão as principais capacidades específicas do iPad.

Drag & Drop

iPadOS suporta Drag & Drop entre aplicativos e dentro de um aplicativo. UIDragInteraction e UIDropInteraction permitem arrastar texto, imagens, arquivos e objetos personalizados. Drag & Drop funciona simultaneamente com Multi-Touch: o usuário pode arrastar vários itens com diferentes dedos. No SwiftUI, os modificadores .onDrag e .onDrop são usados.

Atalhos de teclado

Ao conectar um teclado (Magic Keyboard, Smart Keyboard), UIKeyCommand permite adicionar atalhos. No iPadOS 17+, os atalhos de teclado são exibidos ao pressionar Cmd. A Apple recomenda suportar combinações padrão: ⌘C (copiar), ⌘V (colar), ⌘F (localizar), ⌘N (novo documento).

Monitores externos

iPadOS 17+ suporta monitores externos com resolução nativa de até 6K (Pro Display XDR). Um aplicativo pode exibir conteúdo em uma tela externa através de UIWindowScene com um identificador de sessão separado. Stage Manager permite colocar até 4 janelas em um monitor externo com dimensões redimensionáveis.

Otimização de aplicativos para iPad

O desenvolvimento para iPadOS requer uma abordagem especial para UI/UX, desempenho e testes. Erros perdoáveis no iPhone tornam-se críticos no iPad devido à tela maior e à multitarefa.

Desempenho e memória

iPad usa chips da série M (M1, M2, M4) com memória unificada de até 16 GB. Apesar do hardware poderoso, um aplicativo no Split View ou Slide Over compartilha recursos com outro aplicativo. A pressão de memória é maior que no iPhone. Use compressão de imagens, carregamento lento de coleções e perfilamento através do Instruments Allocations. iPad Pro M4 com 16 GB permite executar aplicativos de nível desktop (Final Cut Pro, Logic Pro).

Design Keyboard First

A maioria dos usuários de iPad usa um teclado externo. A interface deve ser totalmente navegável por teclado: Tab para navegação entre campos, Space para ativar um elemento selecionado, Enter para confirmar. Adicione suporte para Full Keyboard Access — uma configuração do sistema que permite controlar qualquer elemento da interface com o teclado.

Testes em dispositivos reais

O simulador do iPad não reproduz completamente o comportamento da multitarefa. Teste em um dispositivo real em diferentes modos: Split View com um aplicativo pesado (Safari com 20 abas), Stage Manager com 4 janelas, Slide Over com troca rápida de aplicativos. Verifique o cenário: o usuário abre o aplicativo do Slide Over, arrasta para o Split View, muda o tamanho, fecha — o aplicativo não deve travar.

// Verificando o modo multitarefa atual no 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 ativo");
    }

    if (isSlideOver) {
        NSLog(@"Modo Slide Over");
    } else if (isFullScreen) {
        NSLog(@"Modo tela cheia");
    } else {
        NSLog(@"Modo Split View");
    }
}