WatchKit — qué es, el framework de Apple Watch y watchOS

¿Qué es WatchKit y cómo funciona?

WatchKit es un framework de Apple que proporciona una API para crear aplicaciones en Apple Watch. A partir de watchOS 2 (2015), las aplicaciones WatchKit se ejecutan directamente en el reloj, no en el iPhone, lo que les permite procesar datos y mostrar la interfaz sin una conexión constante con el teléfono. Antes de eso, en watchOS 1, todas las aplicaciones se ejecutaban en el iPhone y el reloj era solo una pantalla remota, lo que provocaba retrasos significativos en la interfaz.

La arquitectura moderna de WatchKit incluye dos componentes: WatchKit App (Storyboard + recursos en el reloj) y WatchKit Extension (código que se ejecuta en el reloj). El usuario instala ambos componentes a través de App Store al instalar la aplicación iOS principal. WatchKit se integra con funciones del sistema: notificaciones (mediante UNUserNotificationCenter), complicaciones (datos en la esfera), Workout API y HealthKit.

Según Counterpoint Research (2025), Apple Watch posee el 52% del mercado mundial de relojes inteligentes, y el usuario medio instala de 6 a 8 aplicaciones de terceros que usan WatchKit o SwiftUI. Las categorías más populares son fitness (56%), salud (22%), navegación (9%) y utilidades (8%).

WatchKit vs SwiftUI para watchOS

SwiftUI es la forma recomendada por Apple para crear interfaces en watchOS a partir de watchOS 6. SwiftUI proporciona sintaxis declarativa y adaptación automática a los tamaños de pantalla. Sin embargo, WatchKit sigue siendo relevante para proyectos iniciados antes de la existencia de SwiftUI, para usar elementos específicos (WKInterfaceMap, WKInterfaceMovie) y en casos donde se requiera soporte para versiones de watchOS anteriores a la 6.

Interfaz de WatchKit: WKInterfaceController y elementos

WKInterfaceController es la clase base para gestionar pantallas en WatchKit. Maneja el ciclo de vida: inicialización (awake(withContext:)), aparición (willActivate), desaparición (didDeactivate) y transferencia de contexto entre controladores. Cada pantalla de la aplicación se representa mediante una subclase separada de WKInterfaceController conectada al Storyboard a través de Interface Builder. La navegación puede ser jerárquica (push) o modal (present).

WatchKit proporciona un conjunto de elementos de interfaz con el prefijo WKInterface: WKInterfaceLabel (texto), WKInterfaceButton (botón), WKInterfaceTable (tabla), WKInterfaceImage (imagen), WKInterfaceMap (mapa) y WKInterfaceGroup (contenedor con bordes redondeados y fondo). Todos los elementos funcionan de forma asíncrona: los cambios en la interfaz se ponen en cola y el sistema los aplica entre ciclos de renderizado, garantizando 30 FPS estables en la pantalla del reloj.

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("¡Hola, Watch!")
    }
    
    override func willActivate() {
        super.willActivate()
        actionButton.setTitle("Iniciar")
    }
    
    @IBAction func didTapButton() {
        pushController(withName: "DetailController", context: nil)
    }
}

WCSession: comunicación entre Watch y iPhone

WCSession es la clase central para la comunicación bidireccional entre Apple Watch y iPhone a través de Bluetooth o Wi-Fi. La sesión permite transferir pequeños diccionarios de datos (updateApplicationContext), enviar mensajes con respuesta inmediata (sendMessage), transferir archivos (transferFile) y sincronizar objetos complejos (transferUserInfo). WCSession funciona de forma asíncrona y selecciona automáticamente el canal de comunicación óptimo.

Para usar WCSession, debe activar la sesión en ambos dispositivos. La aplicación Watch crea una WCSession en el método willActivate(), mientras que la aplicación iOS lo hace en AppDelegate o SceneDelegate. Una vez activada, los dispositivos sincronizan automáticamente el contexto cuando es posible. Es importante manejar el delegado WCSessionDelegate para recibir datos entrantes y monitorear el estado de la conexión.

Ejemplo de WCSession en el lado del 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: datos en la esfera del reloj

Complications son pequeños elementos de datos que se muestran en la esfera del Apple Watch y proporcionan acceso rápido a la información sin abrir la aplicación. WatchKit proporciona CLKComplicationDataSource, un protocolo cuya implementación permite a la aplicación suministrar datos para las complicaciones. La esfera del reloj decide qué posiciones están disponibles: circulares, rectangulares, de esquina o modulares.

El desarrollador puede proporcionar complicaciones para tres familias de tamaño: CLKComplicationFamily — circularSmall, extraLarge, graphicCircular, graphicRectangular, graphicCorner, graphicBezel, modularSmall, modularLarge y utilitarianSmall/Large. Cada familia tiene sus propias dimensiones y formato de visualización. Una aplicación puede soportar varias familias, pero se recomienda un mínimo de dos: gráfica y modular.

Ejemplo 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)
    }
}

Ejemplo de aplicación WatchKit en Swift

La creación de una aplicación WatchKit comienza añadiendo un WatchKit App Target en Xcode. Xcode genera un Interface.storyboard con un controlador inicial y lo enlaza automáticamente con la clase InterfaceController. El desarrollador añade elementos de interfaz mediante Interface Builder y crea IBOutlets para la interacción desde el código. A continuación, se muestra un ejemplo completo de un controlador con una tabla de datos recibidos del iPhone a través de 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 aplicaciones de fitness

Workout API es un conjunto de clases de WatchKit para crear aplicaciones de fitness que pueden ejecutar entrenamientos en Apple Watch en segundo plano. La API proporciona acceso a sensores: acelerómetro, giroscopio, monitor de ritmo cardíaco (a través de HKHealthStore) y GPS (en modelos de Watch con GPS). Los entrenamientos se inician mediante HKWorkoutSession de HealthKit, y los datos del ritmo cardíaco se actualizan en tiempo real a través de HKSampleQuery.

La ventaja clave de Workout API es la operación en segundo plano. Cuando un entrenamiento está activo, watchOS no suspende la aplicación al bajar la muñeca: los sensores continúan recogiendo datos y la aplicación puede mostrar el ritmo cardíaco, la distancia, el ritmo y otras métricas. Al finalizar el entrenamiento, los datos se sincronizan con la aplicación Salud en el iPhone a través de HealthKit, proporcionando un perfil de fitness unificado para el usuario.

Iniciar un entrenamiento con 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()
    }
}