Watch App: o que é, desenvolvimento para Apple Watch e Wear OS

O que é Watch App

Watch App é um aplicativo projetado para funcionar em dispositivos vestíveis: Apple Watch (watchOS) e smartwatches com Wear OS. A principal diferença de um aplicativo móvel é o fator de forma. A tela do relógio tem uma diagonal de 1,5–2 polegadas (contra 6–7 polegadas de um smartphone), o que limita a quantidade de informações exibidas simultaneamente. A interação com o aplicativo é curta — o usuário verifica a hora, notificação, frequência cardíaca ou passos em 5–15 segundos e depois abaixa o braço.

Cenários principais do Watch App: rastreador de fitness (passos, frequência cardíaca, calorias, sono), notificações (mensagens, chamadas, calendário), ações rápidas (iniciar timer, responder mensagem por voz, controlar música), companheiro (controle remoto da câmera, chaves do carro, pagamento NFC). De acordo com a Counterpoint Research (2026), o mercado global de smartwatches ultrapassa 150 milhões de dispositivos por ano, dos quais o Apple Watch detém 35%, o Wear OS 20% e o restante Fitbit, Garmin e outros.

Limitações do Watch App: tela pequena (até 2 polegadas), vida útil limitada da bateria (até 18–24 horas), sem teclado completo (apenas entrada de voz ou ditado), limite de tarefas em segundo plano (watchOS — até 10 minutos, Wear OS — até 5 minutos), necessidade de sincronização com o telefone para a maioria das funções. A partir do watchOS 6 (2019) e Wear OS 3 (2022), os aplicativos podem funcionar autonomamente via módulo LTE sem estarem pareados com um telefone.

Apple Watch: watchOS e SwiftUI

watchOS é o sistema operacional da Apple para smartwatches, baseado no iOS e usando os mesmos frameworks (Foundation, UIKit em versão adaptada, SwiftUI). O desenvolvimento é feito no Xcode usando Swift. O principal framework de UI é o SwiftUI, que fornece componentes específicos do watchOS: TabView com carrossel, NavigationStack, Digital Crown via DigitalCrownModifier, menu de pressão longa.

Navegação no watchOS é construída em um paradigma hierárquico. Elementos principais: pilha hierárquica (NavigationStack com retorno automático), apresentações modais (sheet), navegação por páginas (via TabView com .tabViewStyle(.page)), menus contextuais ao pressionar longamente. O Digital Crown permite rolar o conteúdo e alterar valores. Gestos: toque, pressão longa, deslizar, Force Touch (até watchOS 7), rotação do Digital Crown.

Frameworks principais do watchOS: HealthKit (acesso a dados de saúde — frequência cardíaca, passos, sono, ECG), CoreMotion (acelerômetro, giroscópio), WatchConnectivity (troca de dados com iPhone), ClockKit (complicações no mostrador), BackgroundTasks (atualizações em segundo plano até 10 minutos), ARKit (efeitos FaceTime no Series 9+). Um Watch App pode ser completo (aplicativo separado no dock) ou uma extensão (simultâneo com a versão iOS).

Wear OS: Kotlin e Compose

Wear OS é a plataforma do Google para smartwatches, baseada no Android. O desenvolvimento moderno é feito em Kotlin com Jetpack Compose for Wear OS — um conjunto de componentes otimizados para telas redondas: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. Diferente do Compose para celular, o Wear OS usa seus próprios modificadores: scrollable para rolagem vertical, swipable para deslizar, RotaryInput para controle da coroa.

Navegação no Wear OS usa um painel lateral (SwipeToDismiss) e telas de cartão. Elementos principais: SwipeDismissableNavHost (navegação com deslizar para voltar), posicionamento de telas (ScalingLazyColumn para listas), carrossel horizontal (Carousel), mostrador do relógio (WatchFace via WatchFaceService). O Google recomenda usar deslize lateral para voltar e rolagem vertical para listas. O botão de energia do relógio abre a lista de aplicativos recentes.

Saúde e sensores no Wear OS: Health Services API (passos, frequência cardíaca, calorias, sono, SpO2 através de provedores de dados), SensorManager (acelerômetro, giroscópio, barômetro, magnetômetro), Location Services (GPS via FusedLocationProvider). O Wear OS 5+ suporta rastreamento de corrida, caminhada, ciclismo e natação com detecção automática do tipo de atividade. Os dados são sincronizados com o Google Fit via Health Connect.

Exemplo de código: Swift para Apple Watch

Vamos ver um aplicativo de monitoramento cardíaco para Apple Watch usando SwiftUI e HealthKit.

import SwiftUI
import HealthKit

// Modelo de dados cardíacos
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

// ViewModel para HealthKit
@Observable
final class HealthViewModel {
    private let healthStore = HKHealthStore()
    var currentHeartRate: Double = 0
    var isAuthorized: Bool = false

    func requestAuthorization() {
        guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)
        else { return }
        let types = Set([heartRateType])
        healthStore.requestAuthorization(toShare: nil, read: types) { success, _ in
            Task { @MainActor in
                self.isAuthorized = success
                if success { self.startHeartRateQuery() }
            }
        }
    }

    func startHeartRateQuery() {
        guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)
        else { return }
        let query = HKObserverQuery(
            sampleType: heartRateType, predicate: nil
        ) { [weak self] _, _, _ in
            self?.fetchLatestHeartRate()
        }
        healthStore.execute(query)
    }

    private func fetchLatestHeartRate() {
        guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)
        else { return }
        let sort = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)
        let query = HKSampleQuery(
            sampleType: heartRateType, predicate: nil,
            limit: 1, sortDescriptors: [sort]
        ) { _, samples, _ in
            guard let sample = samples?.first as? HKQuantitySample else { return }
            let bpm = sample.quantity.doubleValue(for: HKUnit.count().unitDivided(by: .minute()))
            Task { @MainActor in
                self.currentHeartRate = bpm
            }
        }
        healthStore.execute(query)
    }
}

// Tela principal
struct HeartRateView: View {
    @State private var viewModel = HealthViewModel()

    var body: some View {
        VStack {
            Image(systemName: "heart.fill")
                .foregroundColor(.red)
                .font(.largeTitle)

            Text("\(Int(viewModel.currentHeartRate))")
                .font(.system(size: 60, weight: .bold, design: .rounded))
                .foregroundColor(.red)

            Text("BPM")
                .font(.caption)
                .foregroundColor(.secondary)
        }
        .padding()
        .onAppear(perform: viewModel.requestAuthorization)
    }
}

Pontos-chave: HKHealthStore solicita acesso aos dados do HealthKit; HKObserverQuery notifica sobre mudanças na frequência cardíaca em tempo real; HKSampleQuery obtém o valor mais recente. O Watch App atualiza automaticamente a UI quando currentHeartRate muda graças ao @Observable. O HealthKit processa dados localmente no dispositivo — não são necessárias solicitações ao servidor.

Exemplo de código: Kotlin para Wear OS

Aplicativo similar para Wear OS em Kotlin com Jetpack Compose e Health Services API.

// MainActivity.kt
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.wear.compose.material.*
import androidx.wear.compose.foundation.arc.BasicArcParams
import com.google.android.horologist.health.HealthService

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            WearAppTheme {
                HeartRateScreen()
            }
        }
    }
}

@Composable
fun HeartRateScreen() {
    var heartRate by remember { mutableIntStateOf(0) }
    var isConnected by remember { mutableStateOf(false) }

    LaunchedEffect(Unit) {
        // HealthService — API para acesso a sensores
        val healthService = HealthService()
        healthService.connect().onSuccess {
            isConnected = true
        }
    }

    Scaffold(
        timeText = { TimeText() },
        vignette = { Vignette(vignettePosition = VignettePosition.TopAndBottom) }
    ) {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .scrollable(state = ScrollState),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {
            Icon(
                imageVector = Icons.Filled.Favorite,
                contentDescription = "Frequência cardíaca",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

            Text(
                text = heartRate.toString(),
                style = MaterialTheme.typography.display1
            )
            Text(
                text = "BPM",
                style = MaterialTheme.typography.caption2
            )
        }
    }
}

Componentes principais do Wear OS: Scaffold com TimeText e Vignette para um layout padrão; modificador .scrollable() para compatibilidade com tela redonda; HealthService (Horologist) para acesso ao sensor cardíaco. O Jetpack Compose for Wear OS adapta automaticamente a interface para telas redondas e quadradas — o desenvolvedor não precisa lidar com diferentes fatores de forma manualmente.