WatchKit — was ist das, das Apple Watch Framework und watchOS

Was ist WatchKit und wie funktioniert es?

WatchKit ist ein Apple-Framework, das eine API zur Erstellung von Anwendungen auf der Apple Watch bereitstellt. Ab watchOS 2 (2015) laufen WatchKit-Apps direkt auf der Uhr und nicht auf dem iPhone, sodass sie Daten verarbeiten und die Benutzeroberfläche ohne ständige Verbindung zum Telefon anzeigen können. Zuvor liefen unter watchOS 1 alle Apps auf dem iPhone und die Uhr war nur ein Remote-Display, was zu erheblichen UI-Verzögerungen führte.

Die moderne WatchKit-Architektur umfasst zwei Komponenten: WatchKit App (Storyboard + Ressourcen auf der Uhr) und WatchKit Extension (Code, der auf der Uhr ausgeführt wird). Der Benutzer installiert beide Komponenten über den App Store bei der Installation der zugehörigen iOS-App. WatchKit integriert sich in Systemfunktionen: Benachrichtigungen (über UNUserNotificationCenter), Komplikationen (Daten auf dem Zifferblatt), Workout API und HealthKit.

Laut Counterpoint Research (2025) hält die Apple Watch 52% des weltweiten Smartwatch-Marktes, und der durchschnittliche Benutzer installiert 6–8 Drittanbieter-Apps, die WatchKit oder SwiftUI verwenden. Die beliebtesten Kategorien sind Fitness (56%), Gesundheit (22%), Navigation (9%) und Dienstprogramme (8%).

WatchKit vs. SwiftUI für watchOS

SwiftUI ist die von Apple empfohlene Methode zur Erstellung von Oberflächen für watchOS ab watchOS 6. SwiftUI bietet deklarative Syntax und automatische Anpassung an Bildschirmgrößen. WatchKit bleibt jedoch relevant für Projekte, die vor dem Erscheinen von SwiftUI begonnen wurden, zur Verwendung spezifischer Elemente (WKInterfaceMap, WKInterfaceMovie) und in Fällen, in denen Unterstützung für watchOS-Versionen unter 6 erforderlich ist.

WatchKit-Oberfläche: WKInterfaceController und Elemente

WKInterfaceController ist die Basisklasse zur Verwaltung von Bildschirmen in WatchKit. Sie verwaltet den Lebenszyklus: Initialisierung (awake(withContext:)), Erscheinen (willActivate), Verschwinden (didDeactivate) und Kontextübergabe zwischen Controllern. Jeder App-Bildschirm wird durch eine separate WKInterfaceController-Unterklasse dargestellt, die über Interface Builder mit dem Storyboard verbunden ist. Die Navigation kann hierarchisch (push) oder modal (present) erfolgen.

WatchKit bietet eine Reihe von Oberflächenelementen mit dem Präfix WKInterface: WKInterfaceLabel (Text), WKInterfaceButton (Schaltfläche), WKInterfaceTable (Tabelle), WKInterfaceImage (Bild), WKInterfaceMap (Karte) und WKInterfaceGroup (Container mit abgerundeten Ecken und Hintergrund). Alle Elemente arbeiten asynchron — UI-Änderungen werden in eine Warteschlange gestellt und vom System zwischen den Renderzyklen angewendet, wodurch stabile 30 FPS auf dem Uhrenbildschirm gewährleistet werden.

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("Starten")
    }
    
    @IBAction func didTapButton() {
        pushController(withName: "DetailController", context: nil)
    }
}

WCSession: Kommunikation zwischen Watch und iPhone

WCSession ist die zentrale Klasse für die bidirektionale Kommunikation zwischen Apple Watch und iPhone über Bluetooth oder Wi-Fi. Die Sitzung ermöglicht die Übertragung kleiner Datenwörterbücher (updateApplicationContext), das Senden von Nachrichten mit sofortiger Antwort (sendMessage), das Übertragen von Dateien (transferFile) und das Synchronisieren komplexer Objekte (transferUserInfo). WCSession arbeitet asynchron und wählt automatisch den optimalen Kommunikationskanal aus.

Um WCSession zu verwenden, müssen Sie die Sitzung auf beiden Geräten aktivieren. Die Watch-App erstellt eine WCSession in der Methode willActivate(), während die iOS-App dies in AppDelegate oder SceneDelegate tut. Nach der Aktivierung synchronisieren die Geräte automatisch den Kontext, wenn möglich. Es ist wichtig, den WCSessionDelegate zu behandeln, um eingehende Daten zu empfangen und den Verbindungsstatus zu überwachen.

WCSession-Beispiel auf der Watch-Seite

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: Daten auf dem Zifferblatt

Complications sind kleine Datenelemente, die auf dem Apple Watch-Zifferblatt angezeigt werden und schnellen Zugriff auf Informationen ermöglichen, ohne die App zu öffnen. WatchKit bietet CLKComplicationDataSource — ein Protokoll, dessen Implementierung es der App ermöglicht, Daten für Komplikationen bereitzustellen. Das Zifferblatt entscheidet selbst, welche Positionen verfügbar sind — kreisförmig, rechteckig, eckig oder modular.

Entwickler können Komplikationen für drei Größenfamilien bereitstellen: CLKComplicationFamily — circularSmall, extraLarge, graphicCircular, graphicRectangular, graphicCorner, graphicBezel, modularSmall, modularLarge und utilitarianSmall/Large. Jede Familie hat ihre eigenen Abmessungen und Anzeigeformate. Eine App kann mehrere Familien unterstützen, aber mindestens zwei — grafisch und modular — werden empfohlen.

CLKComplicationDataSource-Beispiel

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

Beispiel einer WatchKit-App in Swift

Die Erstellung einer WatchKit-App beginnt mit dem Hinzufügen eines WatchKit App Targets in Xcode. Xcode generiert ein Interface.storyboard mit einem anfänglichen Controller und verknüpft es automatisch mit der Klasse InterfaceController. Der Entwickler fügt UI-Elemente über Interface Builder hinzu und erstellt IBOutlets für die Interaktion aus dem Code. Unten ist ein vollständiges Beispiel eines Controllers mit einer Tabelle von Daten, die über WCSession vom iPhone empfangen wurden.

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 für Fitnessanwendungen

Workout API ist eine Sammlung von WatchKit-Klassen zur Erstellung von Fitness-Apps, die Workouts auf der Apple Watch im Hintergrund ausführen können. Die API bietet Zugriff auf Sensoren: Beschleunigungsmesser, Gyroskop, Herzfrequenzmesser (über HKHealthStore) und GPS (bei Watch-Modellen mit GPS). Workouts werden über HKWorkoutSession von HealthKit gestartet, und Herzfrequenzdaten werden in Echtzeit über HKSampleQuery aktualisiert.

Der Hauptvorteil der Workout API ist der Hintergrundbetrieb. Wenn ein Training aktiv ist, pausiert watchOS die App nicht, wenn der Benutzer das Handgelenk senkt — die Sensoren sammeln weiterhin Daten und die App kann Herzfrequenz, Distanz, Tempo und andere Metriken anzeigen. Nach Beendigung des Trainings werden die Daten über HealthKit mit der Health-App auf dem iPhone synchronisiert, wodurch ein einheitliches Fitnessprofil für den Benutzer entsteht.

Starten eines Trainings mit 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()
    }
}