Watch App: cos'è, sviluppo per Apple Watch e Wear OS

Cos'è Watch App

Watch App è un'applicazione progettata per funzionare su dispositivi indossabili: Apple Watch (watchOS) e smartwatch con Wear OS. La differenza principale rispetto a un'app mobile è il fattore di forma. Lo schermo dell'orologio ha una diagonale di 1,5–2 pollici (contro i 6–7 pollici di uno smartphone), limitando la quantità di informazioni visualizzate contemporaneamente. L'interazione con l'app è breve — l'utente controlla ora, notifica, frequenza cardiaca o passi in 5–15 secondi, poi abbassa il braccio.

Scenari chiave di Watch App: tracker fitness (passi, frequenza cardiaca, calorie, sonno), notifiche (messaggi, chiamate, calendario), azioni rapide (avviare timer, rispondere a un messaggio con la voce, controllare la musica), compagno (telecomando fotocamera, chiavi auto, pagamento NFC). Secondo Counterpoint Research (2026), il mercato globale degli smartwatch supera i 150 milioni di dispositivi all'anno, di cui Apple Watch detiene il 35%, Wear OS il 20%, il resto Fitbit, Garmin e altri.

Limitazioni di Watch App: schermo piccolo (fino a 2 pollici), durata limitata della batteria (fino a 18–24 ore), nessuna tastiera completa (solo input vocale o dettatura), limite attività in background (watchOS — fino a 10 minuti, Wear OS — fino a 5 minuti), necessità di sincronizzazione con il telefono per la maggior parte delle funzioni. A partire da watchOS 6 (2019) e Wear OS 3 (2022), le app possono funzionare autonomamente tramite modulo LTE senza essere accoppiate a un telefono.

Apple Watch: watchOS e SwiftUI

watchOS è il sistema operativo di Apple per smartwatch, basato su iOS e che utilizza gli stessi framework (Foundation, UIKit in versione adattata, SwiftUI). Lo sviluppo avviene in Xcode con Swift. Il framework UI principale è SwiftUI, che fornisce componenti specifici di watchOS: TabView con carosello, NavigationStack, Digital Crown tramite DigitalCrownModifier, menu a pressione prolungata.

Navigazione su watchOS è costruita su un paradigma gerarchico. Elementi principali: pila gerarchica (NavigationStack con ritorno automatico), presentazioni modali (sheet), navigazione a pagine (tramite TabView con .tabViewStyle(.page)), menu contestuali con pressione prolungata. La Digital Crown consente di scorrere il contenuto e modificare i valori. Gesti: tocco, pressione prolungata, scorrimento, Force Touch (fino a watchOS 7), rotazione della Digital Crown.

Framework chiave di watchOS: HealthKit (accesso ai dati sanitari — frequenza cardiaca, passi, sonno, ECG), CoreMotion (accelerometro, giroscopio), WatchConnectivity (scambio dati con iPhone), ClockKit (complicazioni sul quadrante), BackgroundTasks (aggiornamenti in background fino a 10 minuti), ARKit (effetti FaceTime su Series 9+). Un Watch App può essere completa (app separata nel dock) o un'estensione (simultanea con la versione iOS).

Wear OS: Kotlin e Compose

Wear OS è la piattaforma di Google per smartwatch, basata su Android. Lo sviluppo moderno avviene in Kotlin con Jetpack Compose for Wear OS — un insieme di componenti ottimizzati per schermi rotondi: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. A differenza di Compose per mobile, Wear OS utilizza propri modificatori: scrollable per lo scorrimento verticale, swipable per lo scorrimento, RotaryInput per il controllo della corona.

Navigazione su Wear OS utilizza un pannello laterale (SwipeToDismiss) e schermi a schede. Elementi principali: SwipeDismissableNavHost (navigazione con scorrimento indietro), posizionamento schermi (ScalingLazyColumn per elenchi), carosello orizzontale (Carousel), quadrante orologio (WatchFace tramite WatchFaceService). Google raccomanda di usare lo scorrimento laterale per tornare indietro e lo scorrimento verticale per gli elenchi. Il pulsante di accensione dell'orologio apre l'elenco delle app recenti.

Salute e sensori su Wear OS: Health Services API (passi, frequenza cardiaca, calorie, sonno, SpO2 tramite fornitori di dati), SensorManager (accelerometro, giroscopio, barometro, magnetometro), Location Services (GPS tramite FusedLocationProvider). Wear OS 5+ supporta il tracciamento di corsa, camminata, ciclismo e nuoto con rilevamento automatico del tipo di attività. I dati vengono sincronizzati con Google Fit tramite Health Connect.

Esempio di codice: Swift per Apple Watch

Esaminiamo un'app di monitoraggio cardiaco per Apple Watch che utilizza SwiftUI e HealthKit.

import SwiftUI
import HealthKit

// Modello dati per la frequenza cardiaca
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

// ViewModel per 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)
    }
}

// Schermata principale
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)
    }
}

Punti chiave: HKHealthStore richiede l'accesso ai dati di HealthKit; HKObserverQuery notifica i cambiamenti della frequenza cardiaca in tempo reale; HKSampleQuery ottiene l'ultimo valore. Watch App aggiorna automaticamente l'interfaccia quando currentHeartRate cambia grazie a @Observable. HealthKit elabora i dati localmente sul dispositivo — non sono necessarie richieste al server.

Esempio di codice: Kotlin per Wear OS

App simile per Wear OS in Kotlin con Jetpack Compose e 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 per accesso ai sensori
        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 = "Frequenza cardiaca",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

            Text(
                text = heartRate.toString(),
                style = MaterialTheme.typography.display1
            )
            Text(
                text = "BPM",
                style = MaterialTheme.typography.caption2
            )
        }
    }
}

Componenti chiave di Wear OS: Scaffold con TimeText e Vignette per un layout standard; modificatore .scrollable() per compatibilità con schermo rotondo; HealthService (Horologist) per l'accesso al sensore cardiaco. Jetpack Compose for Wear OS adatta automaticamente l'interfaccia a schermi rotondi e quadrati — lo sviluppatore non deve gestire diversi fattori di forma manualmente.