watchOS : les bases du développement Apple Watch avec SwiftUI

Qu'est-ce que watchOS ?

watchOS est le système d'exploitation des montres connectées Apple, basé sur le noyau XNU de Darwin. Lancé pour la première fois le 24 avril 2015 avec l'Apple Watch Series 0. Le système est construit sur la même architecture qu'iOS, mais optimisé pour un petit écran (de 1,5 à 1,9 pouce), une mémoire limitée (jusqu'à 1 Go de RAM sur Series 9) et une consommation d'énergie minimale.

Selon StatCounter (2026), watchOS détient environ 55 % du marché des systèmes d'exploitation pour montres connectées, devançant Wear OS et les systèmes propriétaires des fabricants chinois. Apple publie des mises à jour majeures de watchOS chaque année, prenant en charge les montres jusqu'à 5 ans après leur lancement.

Une caractéristique clé de watchOS est sa dépendance à l'iPhone. La plupart des applications utilisent Watch Connectivity pour la synchronisation des données. À partir de watchOS 6, les montres peuvent installer des applications directement depuis l'App Store, mais l'indépendance totale vis-à-vis de l'iPhone n'est prise en charge qu'avec watchOS 9.

Historique des versions de watchOS

La première version Watch OS 1.0 ne prenait pas en charge les applications tierces — seulement les applications Apple préinstallées. watchOS 2 (2015) a ouvert le SDK aux développeurs. watchOS 3 (2016) a accéléré le lancement des applications de 7 fois. watchOS 6 (2019) a introduit l'App Store sur la montre. watchOS 9 (2022) a ajouté les médicaments et un suivi du sommeil amélioré. watchOS 10 (2023) est devenu la plus grande mise à jour de l'interface depuis son lancement.

Architecture de watchOS

L'architecture de watchOS se compose de trois couches, isolant le matériel des applications utilisateur. Contrairement à iOS, watchOS utilise une approche basée sur les composants : une application se compose de deux cibles — une extension et un hôte sur l'iPhone.

Noyau et services système

La couche inférieure est un noyau XNU modifié avec des pilotes pour les puces S4/S5/S6/S7/S8/S9 d'Apple. L'Apple Watch Series 9 utilise le S9 SiP avec 5,6 milliards de transistors et un Neural Engine à 4 cœurs. Les services système incluent Core Bluetooth, Watch Connectivity, HealthKit et Core Motion. Toutes les tâches en arrière-plan sont gérées par BGTaskScheduler — un planificateur système qui optimise la consommation d'énergie.

WatchKit — couche applicative

WatchKit est un framework pour créer des interfaces d'applications watchOS. Il comprend WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel et WKInterfaceButton. Depuis watchOS 6, Apple recommande SwiftUI plutôt que WatchKit. SwiftUI offre les mêmes capacités mais avec une syntaxe déclarative et une adaptation automatique à la taille de l'écran : 38 mm (272×340), 42 mm (312×390), 40 mm (324×394), 44 mm (368×448), 45 mm (396×484), 49 mm (410×502 sur Apple Watch Ultra).

Modes d'arrière-plan et consommation d'énergie

watchOS limite l'activité en arrière-plan des applications pour économiser la batterie. Modes d'arrière-plan disponibles : Workout (entraînements), HealthKit (surveillance de la santé), Location (géolocalisation), Audio (lecteur audio) et Complication (données sur le cadran). Chaque mode nécessite une capability distincte dans les entitlements. Consommation d'énergie typique : application active — 50-80 mA, mode arrière-plan — 5-15 mA, veille — 1-3 mA.

import BackgroundTasks
import WatchKit

/// Planification des mises à jour de données en arrière-plan sur 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)
            }
        }
    }
}

/// Enregistrement d'une tâche d'arrière-plan dans 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 garantit que les tâches en arrière-plan s'exécutent à des moments optimaux — lorsque la montre est en charge et connectée à l'iPhone. WKExtensionDelegate traite les tâches en arrière-plan entrantes et met à jour les données sur le cadran. ComplicationController.reloadComplications met à jour les widgets sur le cadran sélectionné.

watchOS 10 : Smart Stack et Double Tap

watchOS 10 — la plus grande mise à jour de l'interface de l'histoire de la plateforme, publiée en septembre 2023. Le système est passé d'une navigation hiérarchique à une navigation orientée contenu : l'écran principal est devenu Smart Stack — une pile intelligente de widgets qui a remplacé le dock d'applications.

Smart Stack

Smart Stack est une liste verticale de widgets affichée sous le cadran de la montre. Les widgets sont classés par contexte : le matin affiche la météo et le calendrier, l'après-midi — l'activité et les rappels, le soir — la méditation et la préparation au sommeil. Le développeur peut ajouter des widgets personnalisés via WidgetKit pour watchOS, en utilisant les mêmes API que pour iOS 17.

Double Tap

Double Tap est un geste de rapprochement de l'index et du pouce, reconnu par l'accéléromètre et le gyroscope sans toucher l'écran. Sur l'Apple Watch Series 9 et Ultra 2, le geste est traité au niveau matériel via le Neural Engine. Le développeur reçoit l'événement via UIDoubleTapGestureRecognizer ou via le modificateur SwiftUI .onTapGesture(count: 2). Le geste ne nécessite pas de calibrage et fonctionne dans n'importe quelle orientation de la main.

Nouvelles API pour les développeurs

watchOS 10 a introduit : SwiftUI Animation avec prise en charge des animations Spring et Keyframe, MapKit pour afficher des cartes sur la montre, VideoPlayer pour lire des vidéos courtes (jusqu'à 30 secondes), VoiceOver amélioré avec des gestes et un nouveau paradigme de navigation NavigationStack à la place de NavigationView.

SwiftUI pour Apple Watch

SwiftUI est le framework principal pour développer les interfaces watchOS. Apple recommande SwiftUI pour tous les nouveaux projets à partir de watchOS 7. SwiftUI pour la montre utilise les mêmes principes que pour iOS, mais avec des modificateurs et des composants spécifiques à watchOS.

Composants SwiftUI spécifiques à watchOS

SwiftUI pour watchOS inclut : TabView avec style de page pour glisser entre les écrans, DigitalCrownRotation pour gérer la rotation de la couronne, SceneStorage pour conserver l'état entre les lancements, WKNotificationScene pour les notifications personnalisées et ComplicationDescriptor pour les données sur le cadran.

import SwiftUI
import HealthKit

/// Application watchOS pour la surveillance du pouls
@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("Pouls", systemImage: "heart.fill") }

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

            SettingsView()
                .tabItem { Label("Paramètres", 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'application HeartMonitorApp illustre une structure typique d'application watchOS en SwiftUI : TabView avec style de page pour glisser entre les écrans, intégration avec HealthKit pour lire le pouls en temps réel, WKNotificationScene pour gérer les notifications. SymbolEffect avec animation pulse utilise l'accélération matérielle du Neural Engine pour une animation fluide sans consommation CPU.

Digital Crown et gestes

La Digital Crown est la molette sur le côté de l'Apple Watch. SwiftUI fournit DigitalCrownRotation pour lier une valeur à la rotation de la couronne. Le modificateur accepte un binding, une plage et un pas. Gestes : tap (toucher), longPress (appui long), swipe (glissement) et pan (glisser-déposer) — tous standard pour SwiftUI et adaptés à la taille de l'écran de la montre.

WatchKit et composants d'une application watchOS

WatchKit est le framework d'origine de watchOS utilisant une approche UIKit. Bien qu'Apple recommande SwiftUI, WatchKit reste pertinent pour les projets hérités et les tâches spécifiques : animations complexes sur WKInterfaceGroup et intégration SiriKit.

Structure d'une application watchOS

Une application watchOS se compose de deux cibles : WatchKit Extension (logique et interface) et iOS Companion App (paramètres et synchronisation). À partir de Xcode 15, il est possible de créer une application autonome sans compagnon iOS. L'interface est décrite dans Interface.storyboard (WatchKit) ou programmatiquement via SwiftUI.

Complications — données sur le cadran

Une Complication est un widget qui affiche des données sur le cadran de l'Apple Watch. Le développeur implémente le protocole CLKComplicationDataSource, fournissant des modèles pour différents types de cadrans (circular, rectangular, modular, extraLarge). watchOS 10 prend en charge ComplicationDescriptor — une API simplifiée pour SwiftUI. Les données sont mises à jour via des tâches d'arrière-plan avec une période allant jusqu'à 30 minutes.

Intégration avec l'iPhone via Watch Connectivity

Watch Connectivity est un framework pour échanger des données entre l'Apple Watch et l'iPhone via Bluetooth ou Wi-Fi. C'est la seule méthode de communication entre les appareils appairés. WCSession est la classe centrale qui gère la session. L'application iOS et l'extension watchOS doivent implémenter WCSessionDelegate.

Méthodes de transfert de données

Watch Connectivity propose quatre méthodes de transfert de données : sendMessage — envoi immédiat avec accusé de réception (fonctionne uniquement lorsque les deux applications sont actives), transferUserInfo — livraison en arrière-plan d'un dictionnaire de données, transferFile — transfert de fichiers avec métadonnées, updateApplicationContext — synchronisation de l'état partagé. Toutes les méthodes garantissent la livraison lors du rétablissement de la connexion.

import WatchConnectivity

/// Gestionnaire de synchronisation entre iPhone et 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 : — Envoi de données de l'iPhone à la montre
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // Si la montre est indisponible — sauvegarder dans le contexte
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("Erreur d'envoi : \(error.localizedDescription)")
        }
    }

    // MARK : — Réception de données sur la montre
    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 activée : \(activationState.rawValue)")
    }

    // Non requis sur watchOS mais obligatoire pour le protocole
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

ConnectivityManager implémente un singleton pour travailler avec WCSession. sendWorkoutData vérifie isReachable : si la montre est active, les données sont envoyées immédiatement via sendMessage ; sinon, elles sont sauvegardées dans applicationContext pour une livraison différée. onReceiveMessage du côté récepteur traite les messages entrants et notifie l'application via NotificationCenter.

Échange de fichiers et synchronisation

transferFile permet de transférer de gros volumes de données : images, fichiers audio, archives. La taille maximale du fichier est de 100 Mo. Les fichiers sont sauvegardés dans le répertoire Inbox sur l'appareil récepteur. transferUserInfo est adapté aux données JSON jusqu'à 100 Ko. Toutes les méthodes fonctionnent en arrière-plan : si l'appareil est indisponible, le transfert est mis en file d'attente et reprend automatiquement lorsque la connexion est rétablie.

Publication d'applications watchOS

La publication d'une application watchOS suit les mêmes règles que iOS : un abonnement Apple Developer Program (99 $/an) et la modération App Review sont requis. L'application est téléchargée sur App Store Connect en tant que partie d'une application iOS ou en tant qu'application autonome.

Compilation et distribution

Une application watchOS peut être distribuée de deux manières : en tant qu'extension intégrée d'une application iOS (le bundle de l'application iOS contient le .app watchOS) ou en tant qu'application autonome (téléchargée et fonctionne sans iPhone). Pour le mode autonome, WKRunsIndependently = YES est requis dans Info.plist. La taille de l'application watchOS est limitée à 50 Mo pour les téléchargements par réseau cellulaire.

Exigences d'App Review

Exigences particulières pour watchOS : l'application doit fonctionner correctement sans iPhone actif (si déclarée comme autonome), l'interface doit être lisible sans zoom, tous les éléments interactifs doivent avoir au moins 44 points de taille. Les applications qui dupliquent des fonctionnalités intégrées (par exemple, un moniteur de pouls sans valeur ajoutée) sont interdites.