WatchKit — che cos'è, il framework Apple Watch e watchOS

Cos'è WatchKit e come funziona?

WatchKit è un framework Apple che fornisce un'API per creare applicazioni su Apple Watch. A partire da watchOS 2 (2015), le app WatchKit vengono eseguite direttamente sull'orologio, non sull'iPhone, consentendo loro di elaborare dati e visualizzare l'interfaccia senza una connessione costante al telefono. Prima di ciò, in watchOS 1, tutte le app venivano eseguite sull'iPhone e l'orologio era solo un display remoto, causando ritardi significativi nell'interfaccia utente.

L'architettura moderna di WatchKit include due componenti: WatchKit App (Storyboard + risorse sull'orologio) e WatchKit Extension (codice eseguito sull'orologio). L'utente installa entrambi i componenti tramite l'App Store durante l'installazione dell'applicazione iOS principale. WatchKit si integra con le funzioni di sistema: notifiche (tramite UNUserNotificationCenter), complicazioni (dati sul quadrante), Workout API e HealthKit.

Secondo Counterpoint Research (2025), Apple Watch detiene il 52% del mercato globale degli smartwatch e l'utente medio installa 6–8 app di terze parti che utilizzano WatchKit o SwiftUI. Le categorie più popolari sono fitness (56%), salute (22%), navigazione (9%) e utilità (8%).

WatchKit vs SwiftUI per watchOS

SwiftUI è il metodo consigliato da Apple per creare interfacce per watchOS a partire da watchOS 6. SwiftUI fornisce sintassi dichiarativa e adattamento automatico alle dimensioni dello schermo. Tuttavia, WatchKit rimane rilevante per i progetti iniziati prima dell'esistenza di SwiftUI, per l'uso di elementi specifici (WKInterfaceMap, WKInterfaceMovie) e nei casi in cui è richiesto il supporto per versioni watchOS precedenti alla 6.

Interfaccia WatchKit: WKInterfaceController ed elementi

WKInterfaceController è la classe base per gestire gli schermi in WatchKit. Gestisce il ciclo di vita: inizializzazione (awake(withContext:)), comparsa (willActivate), scomparsa (didDeactivate) e trasferimento del contesto tra controller. Ogni schermo dell'applicazione è rappresentato da una sottoclasse separata di WKInterfaceController collegata allo Storyboard tramite Interface Builder. La navigazione può essere gerarchica (push) o modale (present).

WatchKit fornisce un insieme di elementi dell'interfaccia con il prefisso WKInterface: WKInterfaceLabel (testo), WKInterfaceButton (pulsante), WKInterfaceTable (tabella), WKInterfaceImage (immagine), WKInterfaceMap (mappa) e WKInterfaceGroup (contenitore con angoli arrotondati e sfondo). Tutti gli elementi funzionano in modo asincrono — le modifiche all'interfaccia vengono messe in coda e applicate dal sistema tra i cicli di rendering, garantendo 30 FPS stabili sullo schermo dell'orologio.

WKInterfaceController di base

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

WCSession: comunicazione tra Watch e iPhone

WCSession è la classe centrale per la comunicazione bidirezionale tra Apple Watch e iPhone tramite Bluetooth o Wi-Fi. La sessione consente di trasferire piccoli dizionari di dati (updateApplicationContext), inviare messaggi con risposta immediata (sendMessage), trasferire file (transferFile) e sincronizzare oggetti complessi (transferUserInfo). WCSession funziona in modo asincrono e seleziona automaticamente il canale di comunicazione ottimale.

Per utilizzare WCSession, è necessario attivare la sessione su entrambi i dispositivi. L'app Watch crea una WCSession nel metodo willActivate(), mentre l'app iOS lo fa in AppDelegate o SceneDelegate. Dopo l'attivazione, i dispositivi sincronizzano automaticamente il contesto quando possibile. È importante gestire il delegato WCSessionDelegate per ricevere i dati in arrivo e monitorare lo stato della connessione.

Esempio WCSession sul lato 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: dati sul quadrante dell'orologio

Complications sono piccoli elementi di dati visualizzati sul quadrante dell'Apple Watch che forniscono accesso rapido alle informazioni senza aprire l'app. WatchKit fornisce CLKComplicationDataSource — un protocollo la cui implementazione consente all'app di fornire dati per le complicazioni. Il quadrante stesso decide quali posizioni sono disponibili — circolari, rettangolari, angolari o modulari.

Lo sviluppatore può fornire complicazioni per tre famiglie di dimensioni: CLKComplicationFamily — circularSmall, extraLarge, graphicCircular, graphicRectangular, graphicCorner, graphicBezel, modularSmall, modularLarge e utilitarianSmall/Large. Ogni famiglia ha le proprie dimensioni e formato di visualizzazione. Un'app può supportare più famiglie, ma si consiglia un minimo di due — grafica e modulare.

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

Esempio di applicazione WatchKit in Swift

La creazione di un'app WatchKit inizia aggiungendo un WatchKit App Target in Xcode. Xcode genera un Interface.storyboard con un controller iniziale e lo collega automaticamente alla classe InterfaceController. Lo sviluppatore aggiunge elementi dell'interfaccia tramite Interface Builder e crea IBOutlets per l'interazione dal codice. Di seguito è riportato un esempio completo di controller con una tabella di dati ricevuti dall'iPhone tramite 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 per applicazioni fitness

Workout API è un insieme di classi WatchKit per creare app per il fitness in grado di eseguire allenamenti su Apple Watch in background. L'API fornisce accesso ai sensori: accelerometro, giroscopio, monitoraggio della frequenza cardiaca (tramite HKHealthStore) e GPS (sui modelli Watch con GPS). Gli allenamenti vengono avviati tramite HKWorkoutSession da HealthKit e i dati della frequenza cardiaca vengono aggiornati in tempo reale tramite HKSampleQuery.

Il vantaggio principale di Workout API è il funzionamento in background. Quando un allenamento è attivo, watchOS non sospende l'app quando l'utente abbassa il polso — i sensori continuano a raccogliere dati e l'app può visualizzare frequenza cardiaca, distanza, ritmo e altre metriche. Al termine dell'allenamento, i dati vengono sincronizzati con l'app Salute sull'iPhone tramite HealthKit, fornendo un profilo fitness unificato per l'utente.

Avviare un allenamento con i sensori

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