Watch App : qu'est-ce que c'est, développement pour Apple Watch et Wear OS

Qu'est-ce que Watch App

Watch App est une application conçue pour fonctionner sur les appareils portables : Apple Watch (watchOS) et montres connectées sous Wear OS. La principale différence avec une application mobile est le facteur de forme. L'écran de la montre a une diagonale de 1,5–2 pouces (contre 6–7 pouces pour un smartphone), ce qui limite la quantité d'informations affichées simultanément. L'interaction avec l'application est courte — l'utilisateur vérifie l'heure, une notification, le pouls ou les pas en 5–15 secondes, puis abaisse la main.

Scénarios clés de Watch App : tracker de fitness (pas, pouls, calories, sommeil), notifications (messages, appels, calendrier), actions rapides (lancer un minuteur, répondre à un message par la voix, contrôler la musique), compagnon (télécommande d'appareil photo, clés de voiture, paiement NFC). Selon Counterpoint Research (2026), le marché mondial des montres connectées dépasse 150 millions d'appareils par an, dont Apple Watch détient 35 %, Wear OS 20 %, le reste Fitbit, Garmin et autres.

Limitations de Watch App : petit écran (jusqu'à 2 pouces), autonomie limitée (jusqu'à 18–24 heures), absence de clavier complet (saisie vocale ou dictée uniquement), limite des tâches en arrière-plan (watchOS — jusqu'à 10 minutes, Wear OS — jusqu'à 5 minutes), nécessité de synchronisation avec le téléphone pour la plupart des fonctions. À partir de watchOS 6 (2019) et Wear OS 3 (2022), les applications peuvent fonctionner de manière autonome via le module LTE sans être appairées à un téléphone.

Apple Watch : watchOS et SwiftUI

watchOS est le système d'exploitation d'Apple pour les montres connectées, basé sur iOS et utilisant les mêmes frameworks (Foundation, UIKit en version adaptée, SwiftUI). Le développement se fait dans Xcode avec Swift. Le framework d'interface principal est SwiftUI, qui fournit des composants spécifiques à watchOS : TabView avec carrousel, NavigationStack, Digital Crown via DigitalCrownModifier, menu d'appui long.

Navigation sur watchOS est construite sur un paradigme hiérarchique. Éléments principaux : pile hiérarchique (NavigationStack avec retour automatique), présentations modales (sheet), navigation par pages (via TabView avec .tabViewStyle(.page)), menus contextuels par appui long. La Digital Crown permet de faire défiler le contenu et de modifier les valeurs. Gestes : toucher, appui long, glissement, Force Touch (jusqu'à watchOS 7), rotation de la Digital Crown.

Frameworks clés de watchOS : HealthKit (accès aux données de santé — pouls, pas, sommeil, ECG), CoreMotion (accéléromètre, gyroscope), WatchConnectivity (échange de données avec iPhone), ClockKit (complications sur le cadran), BackgroundTasks (mises à jour en arrière-plan jusqu'à 10 minutes), ARKit (effets FaceTime sur Series 9+). Une Watch App peut être complète (application séparée dans le dock) ou une extension (simultanée avec la version iOS).

Wear OS : Kotlin et Compose

Wear OS est la plateforme de Google pour les montres connectées, basée sur Android. Le développement moderne se fait en Kotlin avec Jetpack Compose for Wear OS — un ensemble de composants optimisés pour les écrans ronds : Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. Contrairement à Compose pour mobile, Wear OS utilise ses propres modificateurs : scrollable pour le défilement vertical, swipable pour le glissement, RotaryInput pour le contrôle de la couronne.

Navigation sur Wear OS utilise un panneau latéral (SwipeToDismiss) et des écrans de cartes. Éléments principaux : SwipeDismissableNavHost (navigation avec glissement arrière), positionnement des écrans (ScalingLazyColumn pour les listes), carrousel horizontal (Carousel), cadran de montre (WatchFace via WatchFaceService). Google recommande d'utiliser le glissement latéral pour revenir en arrière et le défilement vertical pour les listes. Le bouton d'alimentation de la montre ouvre la liste des applications récentes.

Santé et capteurs sur Wear OS : Health Services API (pas, pouls, calories, sommeil, SpO2 via des fournisseurs de données), SensorManager (accéléromètre, gyroscope, baromètre, magnétomètre), Location Services (GPS via FusedLocationProvider). Wear OS 5+ prend en charge le suivi de la course, de la marche, du cyclisme et de la natation avec détection automatique du type d'activité. Les données sont synchronisées avec Google Fit via Health Connect.

Exemple de code : Swift pour Apple Watch

Examinons une application de surveillance du pouls pour Apple Watch utilisant SwiftUI et HealthKit.

import SwiftUI
import HealthKit

// Modèle de données pour le pouls
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

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

// Écran principal
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)
    }
}

Points clés : HKHealthStore demande l'accès aux données HealthKit ; HKObserverQuery notifie des changements de pouls en temps réel ; HKSampleQuery obtient la dernière valeur. Watch App met automatiquement à jour l'interface lorsque currentHeartRate change grâce à @Observable. HealthKit traite les données localement sur l'appareil — aucune requête serveur n'est nécessaire.

Exemple de code : Kotlin pour Wear OS

Application similaire pour Wear OS en Kotlin avec Jetpack Compose et 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 d'accès aux capteurs
        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 = "Rythme cardiaque",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

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

Composants clés de Wear OS : Scaffold avec TimeText et Vignette pour une mise en page standard ; modificateur .scrollable() pour la compatibilité avec les écrans ronds ; HealthService (Horologist) pour l'accès au capteur cardiaque. Jetpack Compose for Wear OS adapte automatiquement l'interface aux écrans ronds et carrés — le développeur n'a pas besoin de gérer différents facteurs de forme manuellement.