WatchKit — o que é, o framework Apple Watch e watchOS

O que é WatchKit e como funciona?

WatchKit é um framework da Apple que fornece uma API para criar aplicações no Apple Watch. A partir do watchOS 2 (2015), os aplicativos WatchKit são executados diretamente no relógio, e não no iPhone, permitindo processar dados e exibir a interface sem uma conexão constante com o telefone. Antes disso, no watchOS 1, todos os aplicativos eram executados no iPhone e o relógio era apenas um display remoto, causando atrasos significativos na interface.

A arquitetura moderna do WatchKit inclui dois componentes: WatchKit App (Storyboard + recursos no relógio) e WatchKit Extension (código executado no relógio). O usuário instala ambos os componentes através da App Store ao instalar o aplicativo iOS principal. O WatchKit integra-se com recursos do sistema: notificações (via UNUserNotificationCenter), complicações (dados no mostrador), Workout API e HealthKit.

De acordo com Counterpoint Research (2025), o Apple Watch detém 52% do mercado global de smartwatches, e o usuário médio instala 6 a 8 aplicativos de terceiros que usam WatchKit ou SwiftUI. As categorias mais populares são fitness (56%), saúde (22%), navegação (9%) e utilitários (8%).

WatchKit vs SwiftUI para watchOS

SwiftUI é a forma recomendada pela Apple para criar interfaces para watchOS a partir do watchOS 6. O SwiftUI fornece sintaxe declarativa e adaptação automática aos tamanhos de tela. No entanto, o WatchKit continua relevante para projetos iniciados antes da existência do SwiftUI, para usar elementos específicos (WKInterfaceMap, WKInterfaceMovie) e em casos onde é necessário suporte para versões do watchOS anteriores à 6.

Interface do WatchKit: WKInterfaceController e elementos

WKInterfaceController é a classe base para gerenciar telas no WatchKit. Ela lida com o ciclo de vida: inicialização (awake(withContext:)), aparecimento (willActivate), desaparecimento (didDeactivate) e transferência de contexto entre controladores. Cada tela do aplicativo é representada por uma subclasse separada de WKInterfaceController conectada ao Storyboard via Interface Builder. A navegação pode ser hierárquica (push) ou modal (present).

O WatchKit fornece um conjunto de elementos de interface com o prefixo WKInterface: WKInterfaceLabel (texto), WKInterfaceButton (botão), WKInterfaceTable (tabela), WKInterfaceImage (imagem), WKInterfaceMap (mapa) e WKInterfaceGroup (contêiner com cantos arredondados e fundo). Todos os elementos funcionam de forma assíncrona — as alterações na interface são enfileiradas e aplicadas pelo sistema entre os ciclos de renderização, garantindo 30 FPS estáveis na tela do relógio.

WKInterfaceController básico

class MainInterfaceController: WKInterfaceController {
    @IBOutlet weak var titleLabel: WKInterfaceLabel!
    @IBOutlet weak var actionButton: WKInterfaceButton!
    
    override func awake(with context: Any?) {
        super.awake(with: context)
        titleLabel.setText("Olá, Watch!")
    }
    
    override func willActivate() {
        super.willActivate()
        actionButton.setTitle("Iniciar")
    }
    
    @IBAction func didTapButton() {
        pushController(withName: "DetailController", context: nil)
    }
}

WCSession: comunicação entre Watch e iPhone

WCSession é a classe central para comunicação bidirecional entre Apple Watch e iPhone via Bluetooth ou Wi-Fi. A sessão permite transferir pequenos dicionários de dados (updateApplicationContext), enviar mensagens com resposta imediata (sendMessage), transferir arquivos (transferFile) e sincronizar objetos complexos (transferUserInfo). O WCSession funciona de forma assíncrona e seleciona automaticamente o canal de comunicação ideal.

Para usar o WCSession, você deve ativar a sessão em ambos os dispositivos. O aplicativo Watch cria uma WCSession no método willActivate(), enquanto o aplicativo iOS faz isso no AppDelegate ou SceneDelegate. Após a ativação, os dispositivos sincronizam automaticamente o contexto quando possível. É importante tratar o delegado WCSessionDelegate para receber dados de entrada e monitorar o estado da conexão.

Exemplo de WCSession no lado do Watch

class SessionManager: NSObject, WCSessionDelegate {
    private let session = WCSession.default
    
    func activate() {
        session.delegate = self
        session.activate()
    }
    
    func sendDataToPhone(key: String, value: Any) {
        guard session.isReachable else { return }
        session.sendMessage([key: value],
            replyHandler: { response in
                print("Response: \(response)")
            },
            errorHandler: { error in
                print("Error: \(error.localizedDescription)")
            }
        )
    }
    
    func session(_ session: WCSession,
               didReceiveMessage message: [String: Any],
               replyHandler: @escaping ([String: Any]) -> Void) {
        handleIncomingData(message)
        replyHandler(["status": "ok"])
    }
}

Complications: dados no mostrador do relógio

Complications são pequenos elementos de dados exibidos no mostrador do Apple Watch que fornecem acesso rápido a informações sem abrir o aplicativo. O WatchKit fornece CLKComplicationDataSource — um protocolo cuja implementação permite que o aplicativo forneça dados para complicações. O mostrador do relógio decide quais posições estão disponíveis — circulares, retangulares, de canto ou modulares.

O desenvolvedor pode fornecer complicações para três famílias de tamanho: CLKComplicationFamily — circularSmall, extraLarge, graphicCircular, graphicRectangular, graphicCorner, graphicBezel, modularSmall, modularLarge e utilitarianSmall/Large. Cada família tem suas próprias dimensões e formato de exibição. Um aplicativo pode suportar várias famílias, mas um mínimo de duas — gráfica e modular — é recomendado.

Exemplo de CLKComplicationDataSource

class ComplicationController: NSObject, CLKComplicationDataSource {
    func getCurrentTimelineEntry(
        for complication: CLKComplication,
        withHandler handler: @escaping (CLKComplicationTimelineEntry?) -> Void
    ) {
        let template = CLKComplicationTemplateModularSmallSimpleText()
        template.textProvider = CLKSimpleTextProvider(text: "96%")
        let entry = CLKComplicationTimelineEntry(
            date: Date(),
            complicationTemplate: template
        )
        handler(entry)
    }
}

Exemplo de aplicativo WatchKit em Swift

Criar um aplicativo WatchKit começa adicionando um WatchKit App Target no Xcode. O Xcode gera um Interface.storyboard com um controlador inicial e o vincula automaticamente à classe InterfaceController. O desenvolvedor adiciona elementos de interface através do Interface Builder e cria IBOutlets para interação a partir do código. Abaixo está um exemplo completo de um controlador com uma tabela de dados recebidos do iPhone via WCSession.

class ItemRowController: NSObject {
    @IBOutlet weak var itemLabel: WKInterfaceLabel!
    
    func configure(with text: String) {
        itemLabel.setText(text)
    }
}

class ListController: WKInterfaceController {
    @IBOutlet weak var itemsTable: WKInterfaceTable!
    private var items: [String] = []
    
    override func awake(with context: Any?) {
        super.awake(with: context)
        items = context as? [String] ?? []
        
        itemsTable.setNumberOfRows(items.count,
            withRowType: "ItemRow")
        for i in 0..if let row = itemsTable
                .rowController(at: i) as? ItemRowController {
                row.configure(with: items[i])
            }
        }
    }
}

Workout API para aplicativos de fitness

Workout API é um conjunto de classes do WatchKit para criar aplicativos de fitness que podem executar treinos no Apple Watch em segundo plano. A API fornece acesso a sensores: acelerômetro, giroscópio, monitor de frequência cardíaca (via HKHealthStore) e GPS (em modelos de Watch com GPS). Os treinos são iniciados via HKWorkoutSession do HealthKit, e os dados de frequência cardíaca são atualizados em tempo real através de HKSampleQuery.

A principal vantagem da Workout API é a operação em segundo plano. Quando um treino está ativo, o watchOS não suspende o aplicativo ao abaixar o pulso — os sensores continuam coletando dados e o aplicativo pode exibir frequência cardíaca, distância, ritmo e outras métricas. Após o término do treino, os dados são sincronizados com o aplicativo Saúde no iPhone via HealthKit, proporcionando um perfil de fitness unificado para o usuário.

Iniciar um treino com sensores

class WorkoutManager: NSObject {
    private let healthStore = HKHealthStore()
    private var session: HKWorkoutSession!
    
    func startWorkout(activityType: HKWorkoutActivityType) {
        let config = HKWorkoutConfiguration()
        config.activityType = activityType
        config.locationType = .outdoor
        
        session = try! HKWorkoutSession(
            healthStore: healthStore,
            configuration: config
        )
        session.startActivity(with: Date())
    }
    
    func stopWorkout() {
        session.stopActivity(with: Date())
        session.end()
    }
}