watchOS: basi dello sviluppo per Apple Watch con SwiftUI

Cos'è watchOS?

watchOS è il sistema operativo per gli smartwatch di Apple, basato sul kernel XNU di Darwin. Rilasciato per la prima volta il 24 aprile 2015 insieme ad Apple Watch Series 0. Il sistema è costruito sulla stessa architettura di iOS, ma ottimizzato per un piccolo schermo (da 1,5 a 1,9 pollici), memoria limitata (fino a 1 GB di RAM in Series 9) e consumo energetico minimo.

Secondo StatCounter (2026), watchOS detiene circa il 55% del mercato dei sistemi operativi per smartwatch, superando Wear OS e i sistemi proprietari dei produttori cinesi. Apple rilascia importanti aggiornamenti di watchOS ogni anno, supportando gli orologi fino a 5 anni dal rilascio.

Una caratteristica fondamentale di watchOS è la sua dipendenza dall'iPhone. La maggior parte delle app utilizza Watch Connectivity per la sincronizzazione dei dati. A partire da watchOS 6, gli orologi possono installare app direttamente dall'App Store, ma l'indipendenza totale dall'iPhone è supportata solo con watchOS 9.

Storia delle versioni di watchOS

La prima versione Watch OS 1.0 non supportava app di terze parti — solo le app Apple preinstallate. watchOS 2 (2015) ha aperto l'SDK agli sviluppatori. watchOS 3 (2016) ha accelerato l'avvio delle app di 7 volte. watchOS 6 (2019) ha introdotto l'App Store sull'orologio. watchOS 9 (2022) ha aggiunto farmaci e monitoraggio del sonno migliorato. watchOS 10 (2023) è diventato il più grande aggiornamento dell'interfaccia dal suo rilascio.

Architettura di watchOS

L'architettura di watchOS è composta da tre livelli, isolando l'hardware dalle applicazioni utente. A differenza di iOS, watchOS utilizza un approccio basato su componenti: un'app è composta da due destinazioni — un'estensione e un host sull'iPhone.

Kernel e servizi di sistema

Il livello inferiore è un kernel XNU modificato con driver per i chip Apple S4/S5/S6/S7/S8/S9. Apple Watch Series 9 utilizza il S9 SiP con 5,6 miliardi di transistor e un Neural Engine a 4 core. I servizi di sistema includono Core Bluetooth, Watch Connectivity, HealthKit e Core Motion. Tutte le attività in background sono gestite da BGTaskScheduler — uno scheduler di sistema che ottimizza il consumo energetico.

WatchKit — livello applicativo

WatchKit è un framework per creare interfacce di app watchOS. Include WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel e WKInterfaceButton. Da watchOS 6, Apple raccomanda SwiftUI invece di WatchKit. SwiftUI offre le stesse capacità ma con sintassi dichiarativa e adattamento automatico alla dimensione dello schermo: 38 mm (272×340), 42 mm (312×390), 40 mm (324×394), 44 mm (368×448), 45 mm (396×484), 49 mm (410×502 su Apple Watch Ultra).

Modalità background e consumo energetico

watchOS limita l'attività in background delle app per risparmiare batteria. Modalità background disponibili: Workout (allenamenti), HealthKit (monitoraggio della salute), Location (geolocalizzazione), Audio (lettore audio) e Complication (dati sul quadrante). Ogni modalità richiede una capability separata negli entitlements. Consumo energetico tipico: app attiva — 50-80 mA, modalità background — 5-15 mA, standby — 1-3 mA.

import BackgroundTasks
import WatchKit

/// Pianificazione degli aggiornamenti dei dati in background su 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)
            }
        }
    }
}

/// Registrazione di un'attività in background in 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 garantisce che le attività in background vengano eseguite nei momenti ottimali — quando l'orologio è in carica e connesso all'iPhone. WKExtensionDelegate gestisce le attività in background in arrivo e aggiorna i dati sul quadrante. ComplicationController.reloadComplications aggiorna i widget sul quadrante selezionato.

watchOS 10: Smart Stack e Double Tap

watchOS 10 — il più grande aggiornamento dell'interfaccia nella storia della piattaforma, rilasciato a settembre 2023. Il sistema è passato dalla navigazione gerarchica alla navigazione orientata ai contenuti: lo schermo principale è diventato Smart Stack — una pila intelligente di widget che ha sostituito il dock delle app.

Smart Stack

Smart Stack è un elenco verticale di widget visualizzato sotto il quadrante. I widget sono classificati per contesto: al mattino mostra meteo e calendario, durante il giorno — attività e promemoria, alla sera — meditazione e preparazione al sonno. Lo sviluppatore può aggiungere widget personalizzati tramite WidgetKit per watchOS, utilizzando le stesse API di iOS 17.

Double Tap

Double Tap è un gesto di unione dell'indice e del pollice, riconosciuto dall'accelerometro e dal giroscopio senza toccare lo schermo. Su Apple Watch Series 9 e Ultra 2, il gesto viene gestito a livello hardware tramite Neural Engine. Lo sviluppatore riceve l'evento tramite UIDoubleTapGestureRecognizer o tramite il modificatore SwiftUI .onTapGesture(count: 2). Il gesto non richiede calibrazione e funziona in qualsiasi orientamento della mano.

Nuove API per sviluppatori

watchOS 10 ha introdotto: SwiftUI Animation con supporto di animazioni Spring e Keyframe, MapKit per visualizzare mappe sull'orologio, VideoPlayer per riprodurre video brevi (fino a 30 secondi), VoiceOver migliorato con gesti e un nuovo paradigma di navigazione NavigationStack al posto di NavigationView.

SwiftUI per Apple Watch

SwiftUI è il framework principale per lo sviluppo di interfacce watchOS. Apple raccomanda SwiftUI per tutti i nuovi progetti a partire da watchOS 7. SwiftUI per l'orologio utilizza gli stessi principi di iOS, ma con modificatori e componenti specifici di watchOS.

Componenti SwiftUI specifici di watchOS

SwiftUI per watchOS include: TabView con stile pagina per scorrere tra le schermate, DigitalCrownRotation per gestire la rotazione della corona, SceneStorage per preservare lo stato tra gli avvii, WKNotificationScene per notifiche personalizzate e ComplicationDescriptor per i dati sul quadrante.

import SwiftUI
import HealthKit

/// App watchOS per il monitoraggio del polso
@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("Polso", systemImage: "heart.fill") }

            StepsView()
                .tabItem { Label("Passi", systemImage: "figure.walk") }

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

L'app HeartMonitorApp mostra una tipica struttura di app watchOS in SwiftUI: TabView con stile pagina per scorrere tra le schermate, integrazione con HealthKit per leggere il polso in tempo reale, WKNotificationScene per gestire le notifiche. SymbolEffect con animazione pulse utilizza l'accelerazione hardware del Neural Engine per un'animazione fluida senza consumo della CPU.

Digital Crown e gesti

La Digital Crown è la rotella laterale dell'Apple Watch. SwiftUI fornisce DigitalCrownRotation per associare un valore alla rotazione della corona. Il modificatore accetta un binding, un intervallo e un passo. Gesti: tap (tocco), longPress (pressione prolungata), swipe (scorrimento) e pan (trascinamento) — tutti standard per SwiftUI e adattati alle dimensioni dello schermo dell'orologio.

WatchKit e componenti di un'app watchOS

WatchKit è il framework originale di watchOS che utilizza un approccio UIKit. Sebbene Apple raccomandi SwiftUI, WatchKit rimane rilevante per progetti legacy e attività specifiche: animazioni complesse su WKInterfaceGroup e integrazione con SiriKit.

Struttura di un'app watchOS

Un'app watchOS è composta da due destinazioni: WatchKit Extension (logica e interfaccia) e iOS Companion App (impostazioni e sincronizzazione). A partire da Xcode 15, è possibile creare un'app autonoma senza companion iOS. L'interfaccia è descritta in Interface.storyboard (WatchKit) o programmaticamente tramite SwiftUI.

Complicazioni — dati sul quadrante

Una Complicazione è un widget che visualizza dati sul quadrante dell'Apple Watch. Lo sviluppatore implementa il protocollo CLKComplicationDataSource, fornendo modelli per diversi tipi di quadranti (circular, rectangular, modular, extraLarge). watchOS 10 supporta ComplicationDescriptor — un'API semplificata per SwiftUI. I dati vengono aggiornati tramite attività in background con un periodo fino a 30 minuti.

Integrazione con iPhone tramite Watch Connectivity

Watch Connectivity è un framework per lo scambio di dati tra Apple Watch e iPhone tramite Bluetooth o Wi-Fi. È l'unico metodo di comunicazione tra dispositivi accoppiati. WCSession è la classe centrale che gestisce la sessione. L'app iOS e l'estensione watchOS devono implementare WCSessionDelegate.

Metodi di trasferimento dati

Watch Connectivity fornisce quattro metodi di trasferimento dati: sendMessage — invio immediato con conferma (funziona solo quando entrambe le app sono attive), transferUserInfo — consegna in background di un dizionario di dati, transferFile — trasferimento di file con metadati, updateApplicationContext — sincronizzazione dello stato condiviso. Tutti i metodi garantiscono la consegna al ripristino della connessione.

import WatchConnectivity

/// Gestore di sincronizzazione tra iPhone e 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: — Invio di dati dall'iPhone all'orologio
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // Se l'orologio non è disponibile — salva nel contesto
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("Errore di invio: \(error.localizedDescription)")
        }
    }

    // MARK: — Ricezione di dati sull'orologio
    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 attivata: \(activationState.rawValue)")
    }

    // Non richiesto su watchOS ma obbligatorio per il protocollo
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

ConnectivityManager implementa un singleton per lavorare con WCSession. sendWorkoutData verifica isReachable: se l'orologio è attivo, i dati vengono inviati immediatamente tramite sendMessage; in caso contrario — vengono salvati in applicationContext per la consegna differita. onReceiveMessage sul lato ricevente elabora i messaggi in arrivo e notifica l'app tramite NotificationCenter.

Scambio di file e sincronizzazione

transferFile consente di trasferire grandi volumi di dati: immagini, file audio, archivi. La dimensione massima del file è di 100 MB. I file vengono salvati nella directory Inbox sul dispositivo ricevente. transferUserInfo è adatto per dati JSON fino a 100 KB. Tutti i metodi funzionano in background: se il dispositivo non è disponibile, il trasferimento viene accodato e ripreso automaticamente al ripristino della connessione.

Pubblicazione di app watchOS

La pubblicazione di un'app watchOS segue le stesse regole di iOS: è richiesto un abbonamento Apple Developer Program ($99/anno) e il superamento della moderazione App Review. L'app viene caricata su App Store Connect come parte di un'app iOS o come app autonoma.

Build e distribuzione

Un'app watchOS può essere distribuita in due modi: come estensione integrata di un'app iOS (il bundle dell'app iOS contiene il .app watchOS) o come app autonoma (scaricata e funziona senza iPhone). Per la modalità autonoma, è richiesto WKRunsIndependently = YES in Info.plist. La dimensione dell'app watchOS è limitata a 50 MB per il download tramite rete cellulare.

Requisiti di App Review

Requisiti speciali per watchOS: l'app deve funzionare correttamente senza un iPhone attivo (se dichiarata come autonoma), l'interfaccia deve essere leggibile senza ingrandimento, tutti gli elementi interattivi devono avere almeno 44 punti di dimensione. Le app che duplicano funzionalità integrate (ad esempio, un monitor del polso senza valore aggiunto) sono vietate.