watchOS: conceptos básicos de desarrollo para Apple Watch con SwiftUI

¿Qué es watchOS?

watchOS es el sistema operativo para los relojes inteligentes de Apple, basado en el núcleo XNU de Darwin. Se lanzó por primera vez el 24 de abril de 2015 junto con el Apple Watch Series 0. El sistema está construido sobre la misma arquitectura que iOS, pero optimizado para una pantalla pequeña (de 1.5 a 1.9 pulgadas), memoria limitada (hasta 1 GB de RAM en Series 9) y consumo mínimo de energía.

Según StatCounter (2026), watchOS posee aproximadamente el 55% del mercado de sistemas operativos para relojes inteligentes, superando a Wear OS y los sistemas propietarios de fabricantes chinos. Apple lanza actualizaciones importantes de watchOS anualmente, dando soporte a los relojes hasta 5 años desde su lanzamiento.

Una característica clave de watchOS es su dependencia del iPhone. La mayoría de las aplicaciones utilizan Watch Connectivity para la sincronización de datos. A partir de watchOS 6, los relojes pueden instalar aplicaciones directamente desde la App Store, pero la independencia total del iPhone solo es compatible con watchOS 9.

Historial de versiones de watchOS

La primera versión, Watch OS 1.0, no admitía aplicaciones de terceros, solo las aplicaciones preinstaladas de Apple. watchOS 2 (2015) abrió el SDK para desarrolladores. watchOS 3 (2016) aceleró el inicio de aplicaciones 7 veces. watchOS 6 (2019) presentó la App Store en el reloj. watchOS 9 (2022) añadió medicamentos y un mejor seguimiento del sueño. watchOS 10 (2023) se convirtió en la mayor actualización de la interfaz desde su lanzamiento.

Arquitectura de watchOS

La arquitectura de watchOS consta de tres capas que aíslan el hardware de las aplicaciones de usuario. A diferencia de iOS, watchOS utiliza un enfoque basado en componentes: una aplicación consta de dos destinos — una extensión y un anfitrión en el iPhone.

Núcleo y servicios del sistema

La capa inferior es un núcleo XNU modificado con controladores para los chips S4/S5/S6/S7/S8/S9 de Apple. El Apple Watch Series 9 utiliza el S9 SiP con 5.6 mil millones de transistores y un Neural Engine de 4 núcleos. Los servicios del sistema incluyen Core Bluetooth, Watch Connectivity, HealthKit y Core Motion. Todas las tareas en segundo plano se gestionan a través de BGTaskScheduler, un planificador del sistema que optimiza el consumo de energía.

WatchKit — capa de aplicaciones

WatchKit es un framework para crear interfaces de aplicaciones watchOS. Incluye WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel y WKInterfaceButton. Desde watchOS 6, Apple recomienda SwiftUI en lugar de WatchKit. SwiftUI ofrece las mismas capacidades pero con sintaxis declarativa y adaptación automática al tamaño de pantalla: 38 mm (272×340), 42 mm (312×390), 40 mm (324×394), 44 mm (368×448), 45 mm (396×484), 49 mm (410×502 en Apple Watch Ultra).

Modos en segundo plano y consumo de energía

watchOS limita la actividad en segundo plano de las aplicaciones para ahorrar batería. Modos en segundo plano disponibles: Workout (entrenamientos), HealthKit (monitoreo de salud), Location (geolocalización), Audio (reproductor de audio) y Complication (datos en la esfera). Cada modo requiere una capability separada en los entitlements. Consumo típico de energía: aplicación activa — 50-80 mA, modo en segundo plano — 5-15 mA, en espera — 1-3 mA.

import BackgroundTasks
import WatchKit

/// Programación de actualizaciones de datos en segundo plano en 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 una tarea en segundo plano en 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)
            }
        }
    }
}

BGTaskScheduler garantiza que las tareas en segundo plano se ejecuten en momentos óptimos — cuando el reloj está cargando y conectado al iPhone. WKExtensionDelegate maneja las tareas en segundo plano entrantes y actualiza los datos en la esfera. ComplicationController.reloadComplications actualiza los widgets en la esfera seleccionada.

watchOS 10: Smart Stack y Double Tap

watchOS 10 — la mayor actualización de la interfaz en la historia de la plataforma, lanzada en septiembre de 2023. El sistema pasó de la navegación jerárquica a la navegación orientada al contenido: la pantalla principal se convirtió en Smart Stack, una pila inteligente de widgets que reemplazó el dock de aplicaciones.

Smart Stack

Smart Stack es una lista vertical de widgets que se muestra debajo de la esfera del reloj. Los widgets se clasifican por contexto: por la mañana se muestra el clima y el calendario, durante el día — actividad y recordatorios, por la noche — meditación y preparación para dormir. Los desarrolladores pueden añadir widgets personalizados a través de WidgetKit para watchOS, usando las mismas API que para iOS 17.

Double Tap

Double Tap es un gesto de juntar el dedo índice y el pulgar, reconocido por el acelerómetro y el giroscopio sin tocar la pantalla. En Apple Watch Series 9 y Ultra 2, el gesto se maneja a nivel de hardware a través del Neural Engine. El desarrollador recibe el evento a través de UIDoubleTapGestureRecognizer o mediante el modificador de SwiftUI .onTapGesture(count: 2). El gesto no requiere calibración y funciona en cualquier orientación de la mano.

Nuevas API para desarrolladores

watchOS 10 introdujo: SwiftUI Animation con soporte de animaciones Spring y Keyframe, MapKit para mostrar mapas en el reloj, VideoPlayer para reproducir videos cortos (hasta 30 segundos), VoiceOver mejorado con gestos y un nuevo paradigma de navegación NavigationStack en lugar de NavigationView.

SwiftUI para Apple Watch

SwiftUI es el framework principal para desarrollar interfaces de watchOS. Apple recomienda SwiftUI para todos los proyectos nuevos a partir de watchOS 7. SwiftUI para el reloj utiliza los mismos principios que para iOS, pero con modificadores y componentes específicos de watchOS.

Componentes de SwiftUI específicos de watchOS

SwiftUI para watchOS incluye: TabView con estilo de página para deslizar entre pantallas, DigitalCrownRotation para manejar la rotación de la corona, SceneStorage para preservar el estado entre lanzamientos, WKNotificationScene para notificaciones personalizadas y ComplicationDescriptor para datos en la esfera del reloj.

import SwiftUI
import HealthKit

/// Aplicación watchOS para monitoreo 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("Pasos", systemImage: "figure.walk") }

            SettingsView()
                .tabItem { Label("Ajustes", 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("lpm")
                .font(.caption)
                .foregroundStyle(.secondary)
        }
    }
}

La aplicación HeartMonitorApp demuestra una estructura típica de aplicación watchOS en SwiftUI: TabView con estilo de página para deslizar entre pantallas, integración con HealthKit para leer el pulso en tiempo real, WKNotificationScene para manejar notificaciones. SymbolEffect con animación pulse utiliza la aceleración por hardware del Neural Engine para una animación suave sin consumo de CPU.

Digital Crown y gestos

La Digital Crown es la rueda lateral del Apple Watch. SwiftUI proporciona DigitalCrownRotation para vincular un valor a la rotación de la corona. El modificador acepta un binding, un rango y un paso. Gestos: tap (toque), longPress (presión larga), swipe (deslizamiento) y pan (arrastre) — todos estándar para SwiftUI y adaptados al tamaño de pantalla del reloj.

WatchKit y componentes de aplicaciones watchOS

WatchKit es el framework original de watchOS que utiliza un enfoque UIKit. Aunque Apple recomienda SwiftUI, WatchKit sigue siendo relevante para proyectos heredados y tareas específicas: animaciones complejas en WKInterfaceGroup e integración con SiriKit.

Estructura de una aplicación watchOS

Una aplicación watchOS consta de dos destinos: WatchKit Extension (lógica e interfaz) y iOS Companion App (configuración y sincronización). A partir de Xcode 15, es posible crear una aplicación independiente sin acompañante de iOS. La interfaz se describe en Interface.storyboard (WatchKit) o mediante programación con SwiftUI.

Complications — datos en la esfera del reloj

Una Complication es un widget que muestra datos en la esfera del Apple Watch. El desarrollador implementa el protocolo CLKComplicationDataSource, proporcionando plantillas para diferentes tipos de esferas (circular, rectangular, modular, extraLarge). watchOS 10 soporta ComplicationDescriptor, una API simplificada para SwiftUI. Los datos se actualizan mediante Background Tasks con un período de hasta 30 minutos.

Integración con iPhone a través de Watch Connectivity

Watch Connectivity es un framework para intercambiar datos entre Apple Watch y iPhone a través de Bluetooth o Wi-Fi. Es el único método de comunicación entre dispositivos emparejados. WCSession es la clase central que gestiona la sesión. La aplicación iOS y la extensión watchOS deben implementar WCSessionDelegate.

Métodos de transferencia de datos

Watch Connectivity proporciona cuatro métodos de transferencia de datos: sendMessage — envío inmediato con confirmación (funciona solo cuando ambas aplicaciones están activas), transferUserInfo — entrega en segundo plano de un diccionario de datos, transferFile — transferencia de archivos con metadatos, updateApplicationContext — sincronización del estado compartido. Todos los métodos garantizan la entrega cuando se restablece la conexión.

import WatchConnectivity

/// Gestor de sincronización entre iPhone y 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: — Envío de datos del iPhone al reloj
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // Si el reloj no está disponible — guardar en contexto
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("Error de envío: \(error.localizedDescription)")
        }
    }

    // MARK: — Recepción de datos en el reloj
    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 activada: \(activationState.rawValue)")
    }

    // No es necesario en watchOS pero es obligatorio para el protocolo
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

ConnectivityManager implementa un singleton para trabajar con WCSession. sendWorkoutData comprueba isReachable: si el reloj está activo, los datos se envían inmediatamente a través de sendMessage; si no, se guardan en applicationContext para su entrega diferida. onReceiveMessage en el lado receptor procesa los mensajes entrantes y notifica a la aplicación a través de NotificationCenter.

Intercambio de archivos y sincronización

transferFile permite transferir grandes volúmenes de datos: imágenes, archivos de audio, archivos comprimidos. El tamaño máximo de archivo es de 100 MB. Los archivos se guardan en el directorio Inbox del dispositivo receptor. transferUserInfo es adecuado para datos JSON de hasta 100 KB. Todos los métodos funcionan en segundo plano: si el dispositivo no está disponible, la transferencia se pone en cola y se reanuda automáticamente cuando se restablece la conexión.

Publicación de aplicaciones watchOS

La publicación de una aplicación watchOS sigue las mismas reglas que iOS: se requiere una suscripción al Apple Developer Program ($99/año) y pasar la moderación de App Review. La aplicación se carga en App Store Connect como parte de una aplicación iOS o como una aplicación independiente.

Compilación y distribución

Una aplicación watchOS puede distribuirse de dos formas: como una extensión integrada de una aplicación iOS (el bundle de la aplicación iOS contiene el .app de watchOS) o como una aplicación independiente (se descarga y funciona sin iPhone). Para el modo independiente, se requiere WKRunsIndependently = YES en Info.plist. El tamaño de la aplicación watchOS está limitado a 50 MB para descargas por red celular.

Requisitos de App Review

Requisitos especiales para watchOS: la aplicación debe funcionar correctamente sin un iPhone activo (si se declara como independiente), la interfaz debe ser legible sin ampliación, todos los elementos interactivos deben tener al menos 44 puntos de tamaño. Están prohibidas las aplicaciones que duplican la funcionalidad integrada (por ejemplo, un monitor de pulso sin valor añadido).