watchOS: fundamentos do desenvolvimento para Apple Watch com SwiftUI

O que é watchOS?

watchOS é o sistema operacional para os relógios inteligentes da Apple, baseado no kernel XNU do Darwin. Foi lançado pela primeira vez em 24 de abril de 2015 junto com o Apple Watch Series 0. O sistema é construído na mesma arquitetura do iOS, mas otimizado para uma tela pequena (de 1,5 a 1,9 polegadas), memória limitada (até 1 GB de RAM no Series 9) e consumo mínimo de energia.

De acordo com a StatCounter (2026), o watchOS detém aproximadamente 55% do mercado de sistemas operacionais para relógios inteligentes, à frente do Wear OS e dos sistemas proprietários de fabricantes chineses. A Apple lança atualizações importantes do watchOS anualmente, suportando relógios por até 5 anos desde o lançamento.

Uma característica fundamental do watchOS é sua dependência do iPhone. A maioria dos aplicativos usa o Watch Connectivity para sincronização de dados. A partir do watchOS 6, os relógios podem instalar aplicativos diretamente da App Store, mas a independência total do iPhone só é suportada com o watchOS 9.

Histórico de versões do watchOS

A primeira versão, Watch OS 1.0, não suportava aplicativos de terceiros — apenas os aplicativos pré-instalados da Apple. O watchOS 2 (2015) abriu o SDK para desenvolvedores. O watchOS 3 (2016) acelerou a inicialização de aplicativos em 7 vezes. O watchOS 6 (2019) apresentou a App Store no relógio. O watchOS 9 (2022) adicionou medicamentos e melhor monitoramento do sono. O watchOS 10 (2023) tornou-se a maior atualização de interface desde o lançamento.

Arquitetura do watchOS

A arquitetura do watchOS consiste em três camadas, isolando o hardware dos aplicativos do usuário. Ao contrário do iOS, o watchOS usa uma abordagem baseada em componentes: um aplicativo consiste em dois alvos — uma extensão e um host no iPhone.

Kernel e serviços do sistema

A camada inferior é um kernel XNU modificado com drivers para os chips S4/S5/S6/S7/S8/S9 da Apple. O Apple Watch Series 9 usa o S9 SiP com 5,6 bilhões de transistores e um Neural Engine de 4 núcleos. Os serviços do sistema incluem Core Bluetooth, Watch Connectivity, HealthKit e Core Motion. Todas as tarefas em segundo plano são gerenciadas através do BGTaskScheduler — um agendador do sistema que otimiza o consumo de energia.

WatchKit — camada de aplicativos

WatchKit é um framework para criar interfaces de aplicativos watchOS. Inclui WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel e WKInterfaceButton. Desde o watchOS 6, a Apple recomenda o SwiftUI em vez do WatchKit. O SwiftUI oferece as mesmas capacidades, mas com sintaxe declarativa e adaptação automática ao tamanho da tela: 38 mm (272×340), 42 mm (312×390), 40 mm (324×394), 44 mm (368×448), 45 mm (396×484), 49 mm (410×502 no Apple Watch Ultra).

Modos em segundo plano e consumo de energia

O watchOS limita a atividade em segundo plano dos aplicativos para economizar bateria. Modos em segundo plano disponíveis: Workout (treinos), HealthKit (monitoramento de saúde), Location (geolocalização), Audio (reprodutor de áudio) e Complication (dados na esfera). Cada modo requer uma capability separada nos entitlements. Consumo típico de energia: aplicativo ativo — 50-80 mA, modo em segundo plano — 5-15 mA, em espera — 1-3 mA.

import BackgroundTasks
import WatchKit

/// Agendamento de atualizações de dados em segundo plano no watchOS
class BackgroundTaskManager: NSObject {

    func scheduleBackgroundRefresh() {
        let request = BGAppRefreshTaskRequest(identifier: "com.example.refresh")
        request.earliestBeginDate = Date(timeIntervalSinceNow: 30 * 60)

        try? BGTaskScheduler.shared.submit(request)
    }

    func handleAppRefresh(task: BGAppRefreshTask) {
        task.expirationHandler = { task.setTaskCompleted(success: false) }

        DataService.shared.fetchData { result in
            switch result {
            case .success:
                ComplicationController.reloadComplications()
                task.setTaskCompleted(success: true)
            case .failure:
                task.setTaskCompleted(success: false)
            }
        }
    }
}

/// Registro de uma tarefa em segundo plano no WKExtensionDelegate
class ExtensionDelegate: NSObject, WKExtensionDelegate {
    let manager = BackgroundTaskManager()

    func handle(_ backgroundTasks: Set<WKBackgroundTask>) {
        for task in backgroundTasks {
            switch task {
            case let refreshTask as BGAppRefreshTask:
                manager.handleAppRefresh(task: refreshTask)
            default:
                task.setTaskCompleted(success: false)
            }
        }
    }
}

O BGTaskScheduler garante que as tarefas em segundo plano sejam executadas em momentos ideais — quando o relógio está carregando e conectado ao iPhone. O WKExtensionDelegate lida com as tarefas em segundo plano recebidas e atualiza os dados na esfera. O ComplicationController.reloadComplications atualiza os widgets na esfera selecionada.

watchOS 10: Smart Stack e Double Tap

watchOS 10 — a maior atualização de interface na história da plataforma, lançada em setembro de 2023. O sistema passou da navegação hierárquica para a navegação orientada a conteúdo: a tela principal tornou-se o Smart Stack — uma pilha inteligente de widgets que substituiu o dock de aplicativos.

Smart Stack

Smart Stack é uma lista vertical de widgets exibida abaixo da esfera do relógio. Os widgets são classificados por contexto: de manhã mostra clima e calendário, durante o dia — atividade e lembretes, à noite — meditação e preparação para dormir. O desenvolvedor pode adicionar widgets personalizados através do WidgetKit para watchOS, usando as mesmas APIs que para iOS 17.

Double Tap

Double Tap é um gesto de juntar o dedo indicador e o polegar, reconhecido pelo acelerômetro e giroscópio sem tocar na tela. No Apple Watch Series 9 e Ultra 2, o gesto é tratado em nível de hardware através do Neural Engine. O desenvolvedor recebe o evento através do UIDoubleTapGestureRecognizer ou através do modificador SwiftUI .onTapGesture(count: 2). O gesto não requer calibração e funciona em qualquer orientação da mão.

Novas APIs para desenvolvedores

O watchOS 10 introduziu: SwiftUI Animation com suporte a animações Spring e Keyframe, MapKit para exibir mapas no relógio, VideoPlayer para reproduzir vídeos curtos (até 30 segundos), VoiceOver melhorado com gestos e um novo paradigma de navegação NavigationStack em vez de NavigationView.

SwiftUI para Apple Watch

SwiftUI é o framework principal para desenvolver interfaces watchOS. A Apple recomenda SwiftUI para todos os novos projetos a partir do watchOS 7. O SwiftUI para o relógio usa os mesmos princípios que para iOS, mas com modificadores e componentes específicos do watchOS.

Componentes SwiftUI específicos do watchOS

SwiftUI para watchOS inclui: TabView com estilo de página para deslizar entre telas, DigitalCrownRotation para lidar com a rotação da coroa, SceneStorage para preservar o estado entre inicializações, WKNotificationScene para notificações personalizadas e ComplicationDescriptor para dados na esfera do relógio.

import SwiftUI
import HealthKit

/// Aplicativo watchOS para monitoramento de pulso
@main
struct HeartMonitorApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        WKNotificationScene(
            controller: NotificationController.self,
            category: "heartAlert"
        )
    }
}

struct ContentView: View {
    @State private var heartRate: Double = 0
    private let healthStore = HKHealthStore()

    var body: some View {
        TabView {
            HeartRateView(rate: heartRate)
                .tabItem { Label("Pulso", systemImage: "heart.fill") }

            StepsView()
                .tabItem { Label("Passos", systemImage: "figure.walk") }

            SettingsView()
                .tabItem { Label("Configurações", systemImage: "gear") }
        }
        .tabViewStyle(.page)
        .onAppear(perform: setupHealthKit)
    }

    private func setupHealthKit() {
        guard HKHealthStore.isHealthDataAvailable() else { return }
        let heartType = HKQuantityType(.heartRate)

        healthStore.requestAuthorization(toShare: nil, read: [heartType]) { success, error in
            guard success else { return }
            startHeartRateQuery()
        }
    }

    private func startHeartRateQuery() {
        let heartType = HKQuantityType(.heartRate)
        let query = HKObserverQuery(sampleType: heartType, predicate: nil) { _, _, error in
            guard error == nil else { return }
            fetchLatestHeartRate()
        }
        healthStore.execute(query)
    }

    private func fetchLatestHeartRate() {
        let heartType = HKQuantityType(.heartRate)
        let sort = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)
        let query = HKSampleQuery(sampleType: heartType, predicate: nil,
                                    limit: 1, sortDescriptors: [sort]) { _, samples, _ in
            guard let sample = samples?.first as? HKQuantitySample else { return }
            let rate = sample.quantity.doubleValue(for: HKUnit(from: "count/min"))
            DispatchQueue.main.async { heartRate = rate }
        }
        healthStore.execute(query)
    }
}

struct HeartRateView: View {
    let rate: Double

    var body: some View {
        VStack(spacing: 12) {
            Image(systemName: "heart.fill")
                .foregroundStyle(.red)
                .font(.system(size: 48))
                .symbolEffect(.pulse)

            Text("\(Int(rate))")
                .font(.system(.title, design: .rounded))
                .contentTransition(.numericText())
                .bold()

            Text("bpm")
                .font(.caption)
                .foregroundStyle(.secondary)
        }
    }
}

O aplicativo HeartMonitorApp demonstra uma estrutura típica de aplicativo watchOS em SwiftUI: TabView com estilo de página para deslizar entre telas, integração com HealthKit para leitura de pulso em tempo real, WKNotificationScene para lidar com notificações. O SymbolEffect com animação pulse usa aceleração por hardware do Neural Engine para animação suave sem consumo de CPU.

Digital Crown e gestos

A Digital Crown é a roda lateral do Apple Watch. O SwiftUI fornece DigitalCrownRotation para vincular um valor à rotação da coroa. O modificador aceita um binding, um intervalo e um passo. Gestos: tap (toque), longPress (pressão longa), swipe (deslize) e pan (arraste) — todos padrão para SwiftUI e adaptados ao tamanho da tela do relógio.

WatchKit e componentes de aplicativos watchOS

WatchKit é o framework original do watchOS que usa uma abordagem UIKit. Embora a Apple recomende SwiftUI, o WatchKit continua relevante para projetos legados e tarefas específicas: animações complexas em WKInterfaceGroup e integração com SiriKit.

Estrutura de um aplicativo watchOS

Um aplicativo watchOS consiste em dois alvos: WatchKit Extension (lógica e interface) e iOS Companion App (configurações e sincronização). A partir do Xcode 15, é possível criar um aplicativo independente sem um acompanhante iOS. A interface é descrita no Interface.storyboard (WatchKit) ou programaticamente via SwiftUI.

Complicações — dados na esfera do relógio

Uma Complicação é um widget que exibe dados na esfera do Apple Watch. O desenvolvedor implementa o protocolo CLKComplicationDataSource, fornecendo modelos para diferentes tipos de esferas (circular, rectangular, modular, extraLarge). O watchOS 10 suporta ComplicationDescriptor — uma API simplificada para SwiftUI. Os dados são atualizados através de Background Tasks com um período de até 30 minutos.

Integração com iPhone via Watch Connectivity

Watch Connectivity é um framework para trocar dados entre Apple Watch e iPhone via Bluetooth ou Wi-Fi. É o único método de comunicação entre dispositivos pareados. WCSession é a classe central que gerencia a sessão. O aplicativo iOS e a extensão watchOS devem implementar WCSessionDelegate.

Métodos de transferência de dados

O Watch Connectivity fornece quatro métodos de transferência de dados: sendMessage — envio imediato com confirmação (funciona apenas quando ambos os aplicativos estão ativos), transferUserInfo — entrega em segundo plano de um dicionário de dados, transferFile — transferência de arquivos com metadados, updateApplicationContext — sincronização de estado compartilhado. Todos os métodos garantem a entrega quando a conexão é restaurada.

import WatchConnectivity

/// Gerenciador de sincronização entre iPhone e Apple Watch
final class ConnectivityManager: NSObject, WCSessionDelegate {

    static let shared = ConnectivityManager()
    private let session = WCSession.default

    override private init() {
        super.init()
        session.delegate = self
        session.activate()
    }

    // MARK: — Envio de dados do iPhone para o relógio
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // Se o relógio estiver indisponível — salvar no contexto
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("Erro de envio: \(error.localizedDescription)")
        }
    }

    // MARK: — Recebimento de dados no relógio
    func session(_ session: WCSession,
                 didReceiveMessage message: [String: Any]) {
        DispatchQueue.main.async {
            NotificationCenter.default.post(
                name: NSNotification.Name("dataReceived"),
                object: message
            )
        }
    }

    func session(_ session: WCSession,
                 activationDidCompleteWith activationState: WCSessionActivationState,
                 error: Error?) {
        print("WCSession ativada: \(activationState.rawValue)")
    }

    // Não necessário no watchOS, mas obrigatório para o protocolo
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

O ConnectivityManager implementa um singleton para trabalhar com WCSession. O sendWorkoutData verifica isReachable: se o relógio estiver ativo, os dados são enviados imediatamente via sendMessage; caso contrário — são salvos no applicationContext para entrega diferida. O onReceiveMessage no lado receptor processa as mensagens recebidas e notifica o aplicativo através do NotificationCenter.

Troca de arquivos e sincronização

O transferFile permite transferir grandes volumes de dados: imagens, arquivos de áudio, arquivos compactados. O tamanho máximo do arquivo é de 100 MB. Os arquivos são salvos no diretório Inbox no dispositivo receptor. O transferUserInfo é adequado para dados JSON de até 100 KB. Todos os métodos funcionam em segundo plano: se o dispositivo estiver indisponível, a transferência é colocada em fila e retomada automaticamente quando a conexão é restaurada.

Publicação de aplicativos watchOS

A publicação de um aplicativo watchOS segue as mesmas regras que o iOS: é necessária uma assinatura do Apple Developer Program ($99/ano) e a aprovação na moderação da App Review. O aplicativo é enviado para o App Store Connect como parte de um aplicativo iOS ou como um aplicativo independente.

Compilação e distribuição

Um aplicativo watchOS pode ser distribuído de duas formas: como uma extensão embutida de um aplicativo iOS (o bundle do aplicativo iOS contém o .app do watchOS) ou como um aplicativo independente (baixado e executado sem iPhone). Para o modo independente, é necessário WKRunsIndependently = YES no Info.plist. O tamanho do aplicativo watchOS é limitado a 50 MB para downloads por rede celular.

Requisitos da App Review

Requisitos especiais para watchOS: o aplicativo deve funcionar corretamente sem um iPhone ativo (se declarado como independente), a interface deve estar legível sem ampliação, todos os elementos interativos devem ter pelo menos 44 pontos de tamanho. Aplicativos que duplicam funcionalidades integradas (por exemplo, um monitor de pulso sem valor agregado) são proibidos.