WatchKit — wat is het, framework voor Apple Watch en watchOS

Wat is WatchKit en hoe werkt het?

WatchKit — het Apple-framework dat API biedt voor het maken van apps op Apple Watch. Sinds watchOS 2 (2015) draaien WatchKit-apps rechtstreeks op het horloge, niet op de iPhone, zodat ze gegevens kunnen verwerken en de interface kunnen weergeven zonder constante verbinding met de telefoon. Daarvoor draaiden in watchOS 1 alle apps op de iPhone en was het horloge slechts een afstandsbediening voor weergave, wat aanzienlijke UI-vertragingen veroorzaakte.

De moderne WatchKit-architectuur omvat twee componenten: WatchKit App (Storyboard + bronnen op het horloge) en WatchKit Extension (code die op het horloge wordt uitgevoerd). De gebruiker installeert beide componenten via de App Store bij het installeren van de bovenliggende iOS-app. WatchKit zorgt voor integratie met systeemfuncties: meldingen (via UNUserNotificationCenter), complicaties (gegevens op de wijzerplaat), Workout API en HealthKit.

Volgens Counterpoint Research (2025) heeft Apple Watch 52% van de wereldwijde smartwatchmarkt en installeert de gemiddelde gebruiker 6–8 apps van derden met WatchKit of SwiftUI. De populairste categorieën zijn fitness (56%), gezondheid (22%), navigatie (9%) en hulpprogramma's (8%).

WatchKit vs SwiftUI voor watchOS

SwiftUI — de door Apple aanbevolen manier om interfaces voor watchOS te maken sinds watchOS 6. SwiftUI biedt declaratieve syntax en automatische aanpassing aan schermformaten. WatchKit blijft echter relevant voor projecten die vóór de komst van SwiftUI zijn gestart, voor het gebruik van specifieke elementen (WKInterfaceMap, WKInterfaceMovie) en in gevallen waar ondersteuning voor watchOS-versies lager dan 6 vereist is.

WatchKit-interface: WKInterfaceController en elementen

WKInterfaceController — de basisklasse voor het beheren van het scherm in WatchKit. Het is verantwoordelijk voor de levenscyclus: initialisatie (awake(withContext:)), verschijnen (willActivate), verdwijnen (didDeactivate) en contextoverdracht tussen controllers. Elk scherm van de app wordt vertegenwoordigd door een aparte subklasse van WKInterfaceController, gekoppeld aan Storyboard via Interface Builder. Navigatie kan hiërarchisch (push) of modaal (present) zijn.

WatchKit biedt een set interface-elementen met het voorvoegsel WKInterface: WKInterfaceLabel (tekst), WKInterfaceButton (knop), WKInterfaceTable (tabel), WKInterfaceImage (afbeelding), WKInterfaceMap (kaart) en WKInterfaceGroup (container met afrondingen en achtergrond). Alle elementen werken asynchroon — UI-wijzigingen worden in een wachtrij geplaatst en door het systeem toegepast tussen renderscycli, wat stabiele 30 FPS op het horlogescherm garandeert.

Basis WKInterfaceController

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

WCSession: communicatie tussen Watch en iPhone

WCSession — de centrale klasse voor bidirectionele communicatie tussen Apple Watch en iPhone via Bluetooth of Wi-Fi. De sessie maakt het mogelijk kleine gegevenswoordenboeken over te dragen (updateApplicationContext), berichten met onmiddellijk antwoord te verzenden (sendMessage), bestanden over te dragen (transferFile) en complexe objecten te synchroniseren (transferUserInfo). WCSession werkt asynchroon en kiest automatisch het optimale communicatiekanaal.

Om WCSession te gebruiken, moet de sessie op beide apparaten worden geactiveerd. De Watch-app maakt WCSession aan in de willActivate()-methode, de iOS-app in AppDelegate of SceneDelegate. Na activering van de sessie synchroniseren de apparaten automatisch de context wanneer mogelijk. Het is belangrijk om de WCSessionDelegate te verwerken voor het ontvangen van inkomende gegevens en het volgen van de verbindingsstatus.

Voorbeeld WCSession aan de Watch-kant

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: gegevens op de wijzerplaat

Complications — kleine gegevenselementen die worden weergegeven op de wijzerplaat van de Apple Watch en snelle toegang bieden tot informatie zonder de app te openen. WatchKit biedt CLKComplicationDataSource — een protocol waarvan de implementatie de app in staat stelt gegevens voor complicaties te leveren. De wijzerplaat beslist zelf welke posities beschikbaar zijn — rond (circular), rechthoekig (rectangular), hoek (corner) of modulair (modular).

De ontwikkelaar kan complicaties leveren voor drie maten families: CLKComplicationFamily — circularSmall, extraLarge, graphicCircular, graphicRectangular, graphicCorner, graphicBezel, modularSmall, modularLarge en utilitarianSmall/Large. Elke familie heeft zijn eigen afmetingen en weergaveformaat. De app kan meerdere families ondersteunen, maar er worden minimaal twee aanbevolen — grafisch en modulair.

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

Voorbeeld van een WatchKit-app in Swift

Het maken van een WatchKit-app begint met het toevoegen van een WatchKit App Target in Xcode. Xcode genereert Interface.storyboard met een initiële controller en koppelt deze automatisch aan de klasse InterfaceController. De ontwikkelaar voegt UI-elementen toe via Interface Builder en maakt IBOutlet voor interactie vanuit code. Hieronder — een volledig voorbeeld van een controller met een tabel met gegevens ontvangen van de 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 voor fitness-apps

Workout API — een set WatchKit-klassen voor het maken van fitness-apps die trainingen op de Apple Watch op de achtergrond kunnen uitvoeren. De API biedt toegang tot sensoren: versnellingsmeter, gyroscoop, hartslagmeter (via HKHealthStore) en GPS (op Watch-modellen met GPS). Trainingen worden gestart via HKWorkoutSession van HealthKit en hartslaggegevens worden in realtime bijgewerkt via HKSampleQuery.

Het belangrijkste voordeel van Workout API is de mogelijkheid om op de achtergrond te werken. Wanneer een training actief is, onderbreekt watchOS de app niet bij het neerlaten van de arm — sensoren blijven gegevens verzamelen en de app kan hartslag, afstand, tempo en andere statistieken weergeven. Na afloop van de training worden de gegevens gesynchroniseerd met de Health App op de iPhone via HealthKit, wat een uniform fitnessprofiel van de gebruiker garandeert.

Training starten met sensoren

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