Watch App: qué es, desarrollo para Apple Watch y Wear OS

Qué es Watch App

Watch App es una aplicación diseñada para funcionar en dispositivos portátiles: Apple Watch (watchOS) y relojes inteligentes con Wear OS. La principal diferencia con una aplicación móvil es el factor de forma. La pantalla del reloj tiene una diagonal de 1.5–2 pulgadas (frente a 6–7 pulgadas de un smartphone), lo que limita la cantidad de información que se muestra simultáneamente. La interacción con la aplicación es breve: el usuario consulta la hora, una notificación, el pulso o los pasos en 5–15 segundos y luego baja la mano.

Escenarios clave de Watch App: rastreador de fitness (pasos, pulso, calorías, sueño), notificaciones (mensajes, llamadas, calendario), acciones rápidas (iniciar temporizador, responder mensaje por voz, controlar música), compañero (control remoto de cámara, llaves del coche, pago NFC). Según Counterpoint Research (2026), el mercado global de relojes inteligentes supera los 150 millones de dispositivos al año, de los cuales Apple Watch tiene el 35%, Wear OS el 20% y el resto Fitbit, Garmin y otros.

Limitaciones de Watch App: pantalla pequeña (hasta 2 pulgadas), duración limitada de la batería (hasta 18–24 horas), sin teclado completo (solo entrada de voz o dictado), límite de tareas en segundo plano (watchOS — hasta 10 minutos, Wear OS — hasta 5 minutos), necesidad de sincronización con el teléfono para la mayoría de las funciones. A partir de watchOS 6 (2019) y Wear OS 3 (2022), las aplicaciones pueden funcionar de forma autónoma a través del módulo LTE sin estar vinculadas a un teléfono.

Apple Watch: watchOS y SwiftUI

watchOS es el sistema operativo de Apple para relojes inteligentes, basado en iOS y que utiliza los mismos frameworks (Foundation, UIKit en versión adaptada, SwiftUI). El desarrollo se realiza en Xcode con Swift. El framework de UI principal es SwiftUI, que proporciona componentes específicos de watchOS: TabView con carrusel, NavigationStack, Digital Crown mediante DigitalCrownModifier, menú de presión prolongada.

Navegación en watchOS se basa en un paradigma jerárquico. Elementos principales: pila jerárquica (NavigationStack con retorno automático), presentaciones modales (sheet), navegación por páginas (mediante TabView con .tabViewStyle(.page)), menús contextuales con pulsación larga. Digital Crown permite desplazar el contenido y cambiar valores. Gestos: toque, pulsación larga, deslizamiento, Force Touch (hasta watchOS 7), giro de Digital Crown.

Frameworks clave de watchOS: HealthKit (acceso a datos de salud — pulso, pasos, sueño, ECG), CoreMotion (acelerómetro, giroscopio), WatchConnectivity (intercambio de datos con iPhone), ClockKit (complicaciones en la esfera), BackgroundTasks (actualizaciones en segundo plano hasta 10 minutos), ARKit (efectos de FaceTime en Series 9+). Una Watch App puede ser completa (aplicación independiente en el dock) o una extensión (simultánea con la versión de iOS).

Wear OS: Kotlin y Compose

Wear OS es la plataforma de Google para relojes inteligentes, basada en Android. El desarrollo moderno se realiza en Kotlin con Jetpack Compose for Wear OS — un conjunto de componentes optimizados para pantallas redondas: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. A diferencia de Compose para móviles, Wear OS usa sus propios modificadores: scrollable para desplazamiento vertical, swipable para deslizar, RotaryInput para control de la corona.

Navegación en Wear OS utiliza un panel lateral (SwipeToDismiss) y pantallas de tarjetas. Elementos principales: SwipeDismissableNavHost (navegación con deslizamiento hacia atrás), posicionamiento de pantallas (ScalingLazyColumn para listas), carrusel horizontal (Carousel), esfera de reloj (WatchFace mediante WatchFaceService). Google recomienda usar deslizamiento lateral para volver y desplazamiento vertical para listas. El botón de encendido del reloj abre la lista de aplicaciones recientes.

Salud y sensores en Wear OS: Health Services API (pasos, pulso, calorías, sueño, SpO2 a través de proveedores de datos), SensorManager (acelerómetro, giroscopio, barómetro, magnetómetro), Location Services (GPS mediante FusedLocationProvider). Wear OS 5+ admite el seguimiento de carrera, caminata, ciclismo y natación con detección automática del tipo de actividad. Los datos se sincronizan con Google Fit a través de Health Connect.

Ejemplo de código: Swift para Apple Watch

Veamos una aplicación de monitoreo de pulso para Apple Watch usando SwiftUI y HealthKit.

import SwiftUI
import HealthKit

// Modelo de datos para el pulso
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)
    }
}

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

Puntos clave: HKHealthStore solicita acceso a los datos de HealthKit; HKObserverQuery notifica cambios en el pulso en tiempo real; HKSampleQuery obtiene el último valor. Watch App actualiza automáticamente la interfaz cuando currentHeartRate cambia gracias a @Observable. HealthKit procesa los datos localmente en el dispositivo — no se necesitan solicitudes al servidor.

Ejemplo de código: Kotlin para Wear OS

Aplicación similar para Wear OS en Kotlin con Jetpack Compose y 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 acceso 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 = "Ritmo cardíaco",
                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 clave de Wear OS: Scaffold con TimeText y Vignette para un diseño estándar; modificador .scrollable() para compatibilidad con pantalla redonda; HealthService (Horologist) para acceso al sensor de pulso. Jetpack Compose for Wear OS adapta automáticamente la interfaz a pantallas redondas y cuadradas — el desarrollador no necesita manejar diferentes factores de forma manualmente.