watchOS: basisprincipes van ontwikkeling voor Apple Watch met SwiftUI

Wat is watchOS?

watchOS — het besturingssysteem voor Apple smartwatches, gebaseerd op de XNU Darwin-kernel. Voor het eerst uitgebracht op 24 april 2015 samen met de Apple Watch Series 0. Het systeem is gebouwd op dezelfde architectuur als iOS, maar geoptimaliseerd voor een klein scherm (1,5 tot 1,9 inch), beperkt geheugen (tot 1 GB RAM in Series 9) en minimaal energieverbruik.

Volgens StatCounter (2026) heeft watchOS ongeveer 55% van de markt voor besturingssystemen voor smartwatches, waarmee het Wear OS en propriëtaire systemen van Chinese fabrikanten overtreft. Apple brengt jaarlijks grote watchOS-updates uit en ondersteunt horloges tot 5 jaar na lancering.

Het belangrijkste kenmerk van watchOS — afhankelijkheid van de iPhone. De meeste apps gebruiken Watch Connectivity voor gegevenssynchronisatie. Vanaf watchOS 6 kunnen horloges apps rechtstreeks vanuit de App Store installeren, maar volledige autonomie zonder iPhone wordt pas ondersteund vanaf watchOS 9.

Geschiedenis van watchOS-versies

De eerste versie Watch OS 1.0 ondersteunde geen apps van derden — alleen vooraf geïnstalleerde Apple-apps. watchOS 2 (2015) opende de SDK voor ontwikkelaars. watchOS 3 (2016) versnelde het starten van apps 7 keer. watchOS 6 (2019) introduceerde de App Store op het horloge. watchOS 9 (2022) voegde medicijnen en verbeterde slaaptracking toe. watchOS 10 (2023) werd de grootste interface-update sinds de lancering.

Architectuur van watchOS

De architectuur van watchOS bestaat uit drie lagen die de hardware isoleren van gebruikersapps. In tegenstelling tot iOS gebruikt watchOS een componentgerichte aanpak: een app bestaat uit twee targets — een extensie en een host op de iPhone.

Kernel en systeemdiensten

De onderste laag — een aangepaste XNU-kernel met stuurprogramma's voor S4/S5/S6/S7/S8/S9 Apple-chips. De Apple Watch Series 9 gebruikt een S9 SiP met 5,6 miljard transistors en een 4-core Neural Engine. Systeemdiensten omvatten Core Bluetooth, Watch Connectivity, HealthKit en Core Motion. Alle achtergrondtaken worden beheerd door BGTaskScheduler — een systeemplanner die het energieverbruik optimaliseert.

WatchKit — de app-laag

WatchKit — een framework voor het maken van watchOS-appinterfaces. Het omvat WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel en WKInterfaceButton. Sinds watchOS 6 raadt Apple SwiftUI aan in plaats van WatchKit. SwiftUI biedt dezelfde mogelijkheden, maar met declaratieve syntaxis en automatische aanpassing aan de schermgrootte: 38 mm (272×340), 42 mm (312×390), 40 mm (324×394), 44 mm (368×448), 45 mm (396×484), 49 mm (410×502 in Apple Watch Ultra).

Achtergrondmodi en energieverbruik

watchOS beperkt achtergrondactiviteit van apps om de batterij te sparen. Beschikbare achtergrondmodi: Workout (trainingen), HealthKit (gezondheidsmonitoring), Location (geolocatie), Audio (audiospeler) en Complication (gegevens op de wijzerplaat). Elke modus vereist een aparte capability in entitlements. Typisch energieverbruik: actieve app — 50-80 mA, achtergrondmodus — 5-15 mA, standby — 1-3 mA.

import BackgroundTasks
import WatchKit

/// Plannen van achtergrondgegevensupdate op 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)
            }
        }
    }
}

/// Registreren van achtergrondtaak 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 garandeert dat achtergrondtaken op optimale momenten worden uitgevoerd — wanneer het horloge aan de lader ligt en verbonden is met de iPhone. WKExtensionDelegate verwerkt inkomende achtergrondtaken en werkt gegevens op de wijzerplaat bij. ComplicationController.reloadComplications werkt widgets op de geselecteerde wijzerplaat bij.

watchOS 10: Smart Stack en Double Tap

watchOS 10 — de grootste interface-update in de geschiedenis van het platform, uitgebracht in september 2023. Het systeem is overgestapt van hiërarchische navigatie naar contentgerichte navigatie: het hoofdscherm werd Smart Stack — een intelligente stapel widgets die de app-dock verving.

Smart Stack

Smart Stack — een verticale lijst met widgets die onder de wijzerplaat wordt weergegeven. Widgets worden gerangschikt op context: 's ochtends worden het weer en de agenda getoond, overdag activiteit en herinneringen, 's avonds meditatie en voorbereiding op de slaap. Ontwikkelaars kunnen aangepaste widgets toevoegen via WidgetKit voor watchOS, met dezelfde API's als voor iOS 17.

Double Tap

Double Tap — een gebaar waarbij wijsvinger en duim worden samengebracht, herkend door de accelerometer en gyroscoop zonder het scherm aan te raken. In Apple Watch Series 9 en Ultra 2 wordt het gebaar op hardwareniveau uitgevoerd via Neural Engine. De ontwikkelaar ontvangt de gebeurtenis via UIDoubleTapGestureRecognizer of via de SwiftUI-modifier .onTapGesture(count: 2). Het gebaar vereist geen kalibratie en werkt in elke handoriëntatie.

Nieuwe API's voor ontwikkelaars

watchOS 10 introduceerde: SwiftUI Animation met ondersteuning voor Spring- en Keyframe-animaties, MapKit voor het weergeven van kaarten op het horloge, VideoPlayer voor het afspelen van korte video's (tot 30 seconden), verbeterde VoiceOver met gebaren en een nieuw navigatieparadigma NavigationStack in plaats van NavigationView.

SwiftUI voor Apple Watch

SwiftUI — het belangrijkste framework voor het ontwikkelen van interfaces op watchOS. Apple raadt SwiftUI aan voor alle nieuwe projecten vanaf watchOS 7. SwiftUI voor horloges gebruikt dezelfde principes als voor iOS, maar met watchOS-specifieke modifiers en componenten.

WatchOS-specifieke SwiftUI-componenten

SwiftUI voor watchOS omvat: TabView met page-stijl voor swipen tussen schermen, DigitalCrownRotation voor het verwerken van kroonrotatie, SceneStorage voor het opslaan van de status tussen starts, WKNotificationScene voor aangepaste meldingen en ComplicationDescriptor voor gegevens op de wijzerplaat.

import SwiftUI
import HealthKit

/// watchOS-app voor hartslagmonitoring
@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("Hartslag", systemImage: "heart.fill") }

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

            SettingsView()
                .tabItem { Label("Instellingen", 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)
        }
    }
}

De app HeartMonitorApp demonstreert de typische structuur van een watchOS-app in SwiftUI: TabView met page-stijl voor swipen tussen schermen, integratie met HealthKit voor realtime hartslagmeting, WKNotificationScene voor het verwerken van meldingen. SymbolEffect met pulse-animatie gebruikt hardwareversnelling van Neural Engine voor vloeiende animatie zonder CPU-belasting.

Digital Crown en gebaren

Digital Crown — de kroon op het zijpaneel van de Apple Watch. SwiftUI biedt DigitalCrownRotation om een waarde te koppelen aan de rotatie van de kroon. De modifier accepteert een binding, bereik en stap. Gebaren: tap (aanraken), longPress (lang indrukken), swipe (vegen) en pan (slepen) — allemaal standaard voor SwiftUI en aangepast aan de schermgrootte van het horloge.

WatchKit en componenten van watchOS-apps

WatchKit — het oorspronkelijke framework voor watchOS, dat de UIKit-benadering gebruikt. Hoewel Apple SwiftUI aanbeveelt, blijft WatchKit relevant voor oudere projecten en specifieke taken: complexe animaties op WKInterfaceGroup en integratie met SiriKit.

Structuur van een watchOS-app

Een watchOS-app bestaat uit twee targets: WatchKit Extension (logica en interface) en iOS Companion App (instellingen en synchronisatie). Sinds Xcode 15 is het mogelijk om een standalone app te maken zonder iOS-companion. De interface wordt beschreven in Interface.storyboard (WatchKit) of programmatisch via SwiftUI.

Complications — gegevens op de wijzerplaat

Complication — een widget die gegevens weergeeft op de wijzerplaat van de Apple Watch. De ontwikkelaar implementeert het CLKComplicationDataSource-protocol door sjablonen te leveren voor verschillende wijzerplaattypen (circular, rectangular, modular, extraLarge). watchOS 10 ondersteunt ComplicationDescriptor — een vereenvoudigde API voor SwiftUI. Gegevens worden bijgewerkt via Background Tasks met een periode van maximaal 30 minuten.

Integratie met iPhone via Watch Connectivity

Watch Connectivity — een framework voor gegevensuitwisseling tussen Apple Watch en iPhone via Bluetooth of Wi-Fi. De enige manier van communicatie tussen gekoppelde apparaten. WCSession — de centrale klasse die de sessie beheert. De iOS-app en watchOS-extensie moeten WCSessionDelegate implementeren.

Methoden voor gegevensoverdracht

Watch Connectivity biedt vier methoden voor gegevensoverdracht: sendMessage — onmiddellijke verzending met bevestiging (werkt alleen wanneer beide apps actief zijn), transferUserInfo — achtergrondlevering van een gegevenswoordenboek, transferFile — bestandsoverdracht met metadata, updateApplicationContext — synchronisatie van de gedeelde status. Alle methoden garanderen levering bij herstel van de verbinding.

import WatchConnectivity

/// Synchronisatiebeheerder tussen iPhone en 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: — Gegevens verzenden van iPhone naar horloge
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // Als horloge niet beschikbaar is — opslaan in context
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("Send error: \(error.localizedDescription)")
        }
    }

    // MARK: — Gegevens ontvangen op horloge
    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 activated: \(activationState.rawValue)")
    }

    // Niet vereist op watchOS, maar verplicht voor protocol
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

ConnectivityManager implementeert een singleton voor werken met WCSession. sendWorkoutData controleert isReachable: als het horloge actief is, worden gegevens onmiddellijk verzonden via sendMessage; zo niet — worden ze opgeslagen in applicationContext voor uitgestelde levering. onReceiveMessage aan de ontvangende kant verwerkt inkomende berichten en stelt de app op de hoogte via NotificationCenter.

Bestandsuitwisseling en synchronisatie

transferFile maakt overdracht van grote hoeveelheden gegevens mogelijk: afbeeldingen, audiobestanden, archieven. Maximale bestandsgrootte — 100 MB. Bestanden worden opgeslagen in de Inbox-map op het ontvangende apparaat. transferUserInfo is geschikt voor JSON-gegevens tot 100 KB. Alle methoden werken op de achtergrond: als het apparaat niet beschikbaar is, wordt de overdracht in de wachtrij geplaatst en automatisch hervat wanneer de verbinding wordt hersteld.

Publiceren van watchOS-apps

Publiceren van een watchOS-app volgt dezelfde regels als iOS: een abonnement op Apple Developer Program ($99/jaar) en het doorlopen van App Review-moderatie zijn vereist. De app wordt geüpload naar App Store Connect als onderdeel van een iOS-app of als standalone app.

Bouwen en distributie

Een watchOS-app kan op twee manieren worden geleverd: als ingebouwde extensie van een iOS-app (iOS app bundle bevat watchOS .app) of als standalone app (wordt gedownload en werkt zonder iPhone). Voor standalone-modus is WKRunsIndependently = YES in Info.plist vereist. De grootte van een watchOS-app is beperkt tot 50 MB voor download via het mobiele netwerk.

App Review-vereisten

Specifieke vereisten voor watchOS: de app moet correct werken zonder actieve iPhone (indien gedeclareerd als standalone), de interface moet leesbaar zijn zonder vergroting, alle interactieve elementen — minimaal 44 punten groot. Apps die de functionaliteit van ingebouwde apps dupliceren (bijv. een hartslagmeter zonder toegevoegde waarde) zijn verboden.