WatchKit — qu'est-ce que c'est, le framework Apple Watch et watchOS

Qu'est-ce que WatchKit et comment ça marche ?

WatchKit est un framework Apple qui fournit une API pour créer des applications sur Apple Watch. À partir de watchOS 2 (2015), les applications WatchKit s'exécutent directement sur la montre, et non sur l'iPhone, ce qui leur permet de traiter les données et d'afficher l'interface sans connexion constante au téléphone. Avant cela, sous watchOS 1, toutes les applications s'exécutaient sur l'iPhone et la montre n'était qu'un affichage à distance, ce qui entraînait des retards importants dans l'interface utilisateur.

L'architecture moderne de WatchKit comprend deux composants : WatchKit App (Storyboard + ressources sur la montre) et WatchKit Extension (code exécuté sur la montre). L'utilisateur installe les deux composants via l'App Store lors de l'installation de l'application iOS parente. WatchKit s'intègre aux fonctions système : notifications (via UNUserNotificationCenter), complications (données sur le cadran), Workout API et HealthKit.

Selon Counterpoint Research (2025), l'Apple Watch détient 52 % du marché mondial des montres connectées, et l'utilisateur moyen installe 6 à 8 applications tierces utilisant WatchKit ou SwiftUI. Les catégories les plus populaires sont le fitness (56 %), la santé (22 %), la navigation (9 %) et les utilitaires (8 %).

WatchKit vs SwiftUI pour watchOS

SwiftUI est la méthode recommandée par Apple pour créer des interfaces pour watchOS à partir de watchOS 6. SwiftUI offre une syntaxe déclarative et une adaptation automatique aux tailles d'écran. Cependant, WatchKit reste pertinent pour les projets commencés avant l'existence de SwiftUI, pour utiliser des éléments spécifiques (WKInterfaceMap, WKInterfaceMovie) et dans les cas où la prise en charge des versions de watchOS antérieures à 6 est nécessaire.

Interface WatchKit : WKInterfaceController et éléments

WKInterfaceController est la classe de base pour gérer les écrans dans WatchKit. Elle gère le cycle de vie : initialisation (awake(withContext:)), apparition (willActivate), disparition (didDeactivate) et transfert de contexte entre les contrôleurs. Chaque écran de l'application est représenté par une sous-classe distincte de WKInterfaceController connectée au Storyboard via Interface Builder. La navigation peut être hiérarchique (push) ou modale (present).

WatchKit fournit un ensemble d'éléments d'interface avec le préfixe WKInterface : WKInterfaceLabel (texte), WKInterfaceButton (bouton), WKInterfaceTable (tableau), WKInterfaceImage (image), WKInterfaceMap (carte) et WKInterfaceGroup (conteneur avec coins arrondis et fond). Tous les éléments fonctionnent de manière asynchrone — les modifications de l'interface sont mises en file d'attente et appliquées par le système entre les cycles de rendu, garantissant 30 images par seconde stables sur l'écran de la montre.

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

WCSession : communication entre Watch et iPhone

WCSession est la classe centrale pour la communication bidirectionnelle entre Apple Watch et iPhone via Bluetooth ou Wi-Fi. La session permet de transférer de petits dictionnaires de données (updateApplicationContext), d'envoyer des messages avec réponse immédiate (sendMessage), de transférer des fichiers (transferFile) et de synchroniser des objets complexes (transferUserInfo). WCSession fonctionne de manière asynchrone et sélectionne automatiquement le canal de communication optimal.

Pour utiliser WCSession, vous devez activer la session sur les deux appareils. L'application Watch crée une WCSession dans la méthode willActivate(), tandis que l'application iOS le fait dans AppDelegate ou SceneDelegate. Une fois activée, les appareils synchronisent automatiquement le contexte lorsque c'est possible. Il est important de gérer le délégué WCSessionDelegate pour recevoir les données entrantes et surveiller l'état de la connexion.

Exemple WCSession côté 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 : données sur le cadran de la montre

Complications sont de petits éléments de données affichés sur le cadran de l'Apple Watch qui permettent un accès rapide aux informations sans ouvrir l'application. WatchKit fournit CLKComplicationDataSource — un protocole dont l'implémentation permet à l'application de fournir des données pour les complications. Le cadran de la montre décide lui-même quelles positions sont disponibles — circulaires, rectangulaires, d'angle ou modulaires.

Le développeur peut fournir des complications pour trois familles de taille : CLKComplicationFamily — circularSmall, extraLarge, graphicCircular, graphicRectangular, graphicCorner, graphicBezel, modularSmall, modularLarge et utilitarianSmall/Large. Chaque famille a ses propres dimensions et format d'affichage. Une application peut prendre en charge plusieurs familles, mais un minimum de deux — graphique et modulaire — est recommandé.

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

Exemple d'application WatchKit en Swift

La création d'une application WatchKit commence par l'ajout d'une cible WatchKit App dans Xcode. Xcode génère un Interface.storyboard avec un contrôleur initial et le lie automatiquement à la classe InterfaceController. Le développeur ajoute des éléments d'interface via Interface Builder et crée des IBOutlets pour l'interaction depuis le code. Voici un exemple complet d'un contrôleur avec un tableau de données reçues de l'iPhone via 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 pour les applications de fitness

Workout API est un ensemble de classes WatchKit pour créer des applications de fitness capables d'exécuter des entraînements sur Apple Watch en arrière-plan. L'API donne accès aux capteurs : accéléromètre, gyroscope, moniteur de fréquence cardiaque (via HKHealthStore) et GPS (sur les modèles de Watch avec GPS). Les entraînements sont démarrés via HKWorkoutSession de HealthKit, et les données de fréquence cardiaque sont mises à jour en temps réel via HKSampleQuery.

L'avantage clé de Workout API est le fonctionnement en arrière-plan. Lorsqu'un entraînement est actif, watchOS ne suspend pas l'application lorsque l'utilisateur baisse le poignet — les capteurs continuent de collecter des données et l'application peut afficher la fréquence cardiaque, la distance, l'allure et d'autres métriques. Après la fin de l'entraînement, les données sont synchronisées avec l'application Santé sur l'iPhone via HealthKit, fournissant un profil de fitness unifié pour l'utilisateur.

Démarrer un entraînement avec des capteurs

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