watchOS: Grundlagen der Apple Watch-Entwicklung mit SwiftUI

Was ist watchOS?

watchOS ist das Betriebssystem für die Smartwatches von Apple, basierend auf dem Darwin-XNU-Kernel. Es wurde erstmals am 24. April 2015 zusammen mit der Apple Watch Series 0 veröffentlicht. Das System basiert auf derselben Architektur wie iOS, ist jedoch für ein kleines Display (1,5 bis 1,9 Zoll), begrenzten Arbeitsspeicher (bis zu 1 GB RAM in der Series 9) und minimale Leistungsaufnahme optimiert.

Laut StatCounter (2026) hält watchOS etwa 55 % des Marktes für Smartwatch-Betriebssysteme und liegt damit vor Wear OS und den proprietären Systemen chinesischer Hersteller. Apple veröffentlicht jährlich große watchOS-Updates und unterstützt die Uhren bis zu 5 Jahre nach der Veröffentlichung.

Ein Hauptmerkmal von watchOS ist seine Abhängigkeit vom iPhone. Die meisten Apps nutzen Watch Connectivity zur Datensynchronisation. Ab watchOS 6 können Uhren Apps direkt aus dem App Store installieren, aber die vollständige Unabhängigkeit vom iPhone wird erst mit watchOS 9 unterstützt.

Versionsgeschichte von watchOS

Die erste Version Watch OS 1.0 unterstützte keine Drittanbieter-Apps — nur vorinstallierte Apple-Apps. watchOS 2 (2015) öffnete das SDK für Entwickler. watchOS 3 (2016) beschleunigte den App-Start um das 7-fache. watchOS 6 (2019) führte den App Store auf der Uhr ein. watchOS 9 (2022) fügte Medikamente und verbessertes Schlaftracking hinzu. watchOS 10 (2023) wurde zum größten Interface-Update seit der Veröffentlichung.

watchOS-Architektur

Die watchOS-Architektur besteht aus drei Schichten, die die Hardware von den Benutzeranwendungen trennen. Im Gegensatz zu iOS verwendet watchOS einen komponentenbasierten Ansatz: Eine App besteht aus zwei Zielen — einer Erweiterung und einem iPhone-Host.

Kernel und Systemdienste

Die unterste Ebene ist ein modifizierter XNU-Kernel mit Treibern für Apples S4/S5/S6/S7/S8/S9-Chips. Die Apple Watch Series 9 verwendet den S9 SiP mit 5,6 Milliarden Transistoren und einer 4-Kern-Neural Engine. Zu den Systemdiensten gehören Core Bluetooth, Watch Connectivity, HealthKit und Core Motion. Alle Hintergrundaufgaben werden von BGTaskScheduler verwaltet — einem Systemplaner, der den Stromverbrauch optimiert.

WatchKit — Anwendungsschicht

WatchKit ist ein Framework zum Erstellen von watchOS-App-Oberflächen. Es umfasst WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel und WKInterfaceButton. Seit watchOS 6 empfiehlt Apple SwiftUI anstelle von WatchKit. SwiftUI bietet die gleichen Fähigkeiten, jedoch mit deklarativem Syntax und automatischer Anpassung an die Bildschirmgröße: 38 mm (272×340), 42 mm (312×390), 40 mm (324×394), 44 mm (368×448), 45 mm (396×484), 49 mm (410×502 auf der Apple Watch Ultra).

Hintergrundmodi und Stromverbrauch

watchOS schränkt die Hintergrundaktivität von Apps ein, um den Akku zu schonen. Verfügbare Hintergrundmodi: Workout (Training), HealthKit (Gesundheitsüberwachung), Location (Geolokalisierung), Audio (Audioplayer) und Complication (Daten auf dem Zifferblatt). Jeder Modus erfordert eine separate Capability in den Entitlements. Typischer Stromverbrauch: aktive App — 50-80 mA, Hintergrundmodus — 5-15 mA, Standby — 1-3 mA.

import BackgroundTasks
import WatchKit

/// Planung von Hintergrunddatenaktualisierungen auf 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)
            }
        }
    }
}

/// Registrieren einer Hintergrundaufgabe 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 stellt sicher, dass Hintergrundaufgaben zu optimalen Zeiten ausgeführt werden — wenn die Uhr aufgeladen und mit dem iPhone verbunden ist. WKExtensionDelegate verarbeitet eingehende Hintergrundaufgaben und aktualisiert Daten auf dem Zifferblatt. ComplicationController.reloadComplications aktualisiert Widgets auf dem ausgewählten Zifferblatt.

watchOS 10: Smart Stack und Double Tap

watchOS 10 — das größte Interface-Update in der Geschichte der Plattform, veröffentlicht im September 2023. Das System wechselte von hierarchischer Navigation zu inhaltsorientierter Navigation: Der Hauptbildschirm wurde zum Smart Stack — einem intelligenten Widget-Stapel, der den App-Dock ersetzte.

Smart Stack

Smart Stack ist eine vertikale Liste von Widgets, die unter dem Zifferblatt angezeigt wird. Die Widgets werden nach Kontext sortiert: Morgens werden Wetter und Kalender angezeigt, tagsüber — Aktivität und Erinnerungen, abends — Meditation und Schlafvorbereitung. Entwickler können über WidgetKit für watchOS benutzerdefinierte Widgets hinzufügen, die dieselben APIs wie für iOS 17 verwenden.

Double Tap

Double Tap ist eine Geste des Zusammenführens von Zeigefinger und Daumen, die vom Beschleunigungssensor und Gyroskop erkannt wird, ohne den Bildschirm zu berühren. Auf der Apple Watch Series 9 und Ultra 2 wird die Geste auf Hardware-Ebene über die Neural Engine verarbeitet. Der Entwickler empfängt das Ereignis über UIDoubleTapGestureRecognizer oder über den SwiftUI-Modifikator .onTapGesture(count: 2). Die Geste erfordert keine Kalibrierung und funktioniert in jeder Handausrichtung.

Neue APIs für Entwickler

watchOS 10 führte ein: SwiftUI Animation mit Unterstützung für Spring- und Keyframe-Animationen, MapKit zur Anzeige von Karten auf der Uhr, VideoPlayer zum Abspielen kurzer Videos (bis zu 30 Sekunden), verbessertes VoiceOver mit Gesten und ein neues Navigationsparadigma NavigationStack anstelle von NavigationView.

SwiftUI für Apple Watch

SwiftUI ist das primäre Framework für die Entwicklung von watchOS-Oberflächen. Apple empfiehlt SwiftUI für alle neuen Projekte ab watchOS 7. SwiftUI für die Uhr verwendet dieselben Prinzipien wie für iOS, jedoch mit watchOS-spezifischen Modifikatoren und Komponenten.

WatchOS-spezifische SwiftUI-Komponenten

SwiftUI für watchOS umfasst: TabView mit Seitenstil zum Wischen zwischen Bildschirmen, DigitalCrownRotation zur Verarbeitung der Kronendrehung, SceneStorage zum Erhalten des Zustands zwischen Starts, WKNotificationScene für benutzerdefinierte Benachrichtigungen und ComplicationDescriptor für Daten auf dem Zifferblatt.

import SwiftUI
import HealthKit

/// watchOS-App zur Pulsüberwachung
@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("Puls", systemImage: "heart.fill") }

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

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

Die App HeartMonitorApp zeigt eine typische watchOS-App-Struktur in SwiftUI: TabView mit Seitenstil zum Wischen zwischen Bildschirmen, HealthKit-Integration zum Lesen der Herzfrequenz in Echtzeit, WKNotificationScene zur Verarbeitung von Benachrichtigungen. SymbolEffect mit Puls-Animation nutzt die Hardwarebeschleunigung der Neural Engine für flüssige Animationen ohne CPU-Belastung.

Digital Crown und Gesten

Die Digital Crown ist das Rad an der Seite der Apple Watch. SwiftUI bietet DigitalCrownRotation zum Binden eines Werts an die Kronendrehung. Der Modifikator akzeptiert ein Binding, einen Bereich und einen Schritt. Gesten: tap (Antippen), longPress (langes Drücken), swipe (Wischen) und pan (Ziehen) — alle Standard für SwiftUI und an die Bildschirmgröße der Uhr angepasst.

WatchKit und Komponenten einer watchOS-App

WatchKit ist das ursprüngliche watchOS-Framework, das einen UIKit-Ansatz verwendet. Obwohl Apple SwiftUI empfiehlt, bleibt WatchKit für Legacy-Projekte und spezifische Aufgaben relevant: komplexe Animationen auf WKInterfaceGroup und SiriKit-Integration.

Struktur einer watchOS-App

Eine watchOS-App besteht aus zwei Zielen: WatchKit Extension (Logik und Oberfläche) und iOS Companion App (Einstellungen und Synchronisation). Ab Xcode 15 ist es möglich, eine eigenständige App ohne iOS-Begleiter zu erstellen. Die Oberfläche wird in Interface.storyboard (WatchKit) oder programmatisch über SwiftUI beschrieben.

Complications — Daten auf dem Zifferblatt

Eine Complication ist ein Widget, das Daten auf dem Apple Watch-Zifferblatt anzeigt. Der Entwickler implementiert das CLKComplicationDataSource-Protokoll und stellt Vorlagen für verschiedene Zifferblatttypen (circular, rectangular, modular, extraLarge) bereit. watchOS 10 unterstützt ComplicationDescriptor — eine vereinfachte API für SwiftUI. Daten werden über Hintergrundaufgaben mit einer Periode von bis zu 30 Minuten aktualisiert.

Integration mit dem iPhone über Watch Connectivity

Watch Connectivity ist ein Framework zum Austausch von Daten zwischen Apple Watch und iPhone über Bluetooth oder Wi-Fi. Es ist die einzige Kommunikationsmethode zwischen gekoppelten Geräten. WCSession ist die zentrale Klasse, die die Sitzung verwaltet. Die iOS-App und die watchOS-Erweiterung müssen WCSessionDelegate implementieren.

Datenübertragungsmethoden

Watch Connectivity bietet vier Datenübertragungsmethoden: sendMessage — sofortiger Versand mit Bestätigung (funktioniert nur, wenn beide Apps aktiv sind), transferUserInfo — Hintergrundzustellung eines Datenwörterbuchs, transferFile — Dateiübertragung mit Metadaten, updateApplicationContext — Synchronisation des gemeinsamen Zustands. Alle Methoden garantieren die Zustellung bei Wiederherstellung der Verbindung.

import WatchConnectivity

/// Sync-Manager zwischen iPhone und 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: — Senden von Daten vom iPhone an die Uhr
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // Wenn die Uhr nicht verfügbar ist — im Kontext speichern
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("Sendefehler: \(error.localizedDescription)")
        }
    }

    // MARK: — Empfangen von Daten auf der Uhr
    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 aktiviert: \(activationState.rawValue)")
    }

    // Auf watchOS nicht erforderlich, aber für das Protokoll obligatorisch
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

ConnectivityManager implementiert ein Singleton für die Arbeit mit WCSession. sendWorkoutData prüft isReachable: Wenn die Uhr aktiv ist, werden die Daten sofort über sendMessage gesendet; andernfalls werden sie im applicationContext für die verzögerte Zustellung gespeichert. onReceiveMessage auf der Empfängerseite verarbeitet eingehende Nachrichten und benachrichtigt die App über NotificationCenter.

Dateiaustausch und Synchronisation

transferFile ermöglicht die Übertragung großer Datenmengen: Bilder, Audiodateien, Archive. Die maximale Dateigröße beträgt 100 MB. Dateien werden im Inbox-Verzeichnis auf dem Empfängergerät gespeichert. transferUserInfo eignet sich für JSON-Daten bis zu 100 KB. Alle Methoden arbeiten im Hintergrund: Wenn das Gerät nicht verfügbar ist, wird die Übertragung in die Warteschlange gestellt und bei Wiederherstellung der Verbindung automatisch fortgesetzt.

Veröffentlichung von watchOS-Apps

Die Veröffentlichung einer watchOS-App folgt denselben Regeln wie iOS: Ein Apple Developer Program-Abonnement (99 $/Jahr) und die App Review-Moderation sind erforderlich. Die App wird als Teil einer iOS-App oder als eigenständige App in App Store Connect hochgeladen.

Build und Verteilung

Eine watchOS-App kann auf zwei Arten bereitgestellt werden: als integrierte iOS-App-Erweiterung (das iOS-App-Bundle enthält die watchOS-.app) oder als eigenständige App (wird ohne iPhone heruntergeladen und ausgeführt). Für den eigenständigen Modus ist WKRunsIndependently = YES in der Info.plist erforderlich. Die Größe der watchOS-App ist auf 50 MB für Mobilfunk-Downloads begrenzt.

App Review-Anforderungen

Besondere Anforderungen für watchOS: Die App muss ohne aktives iPhone korrekt funktionieren (wenn als eigenständig deklariert), die Oberfläche muss ohne Vergrößerung lesbar sein, alle interaktiven Elemente müssen mindestens 44 Punkte groß sein. Apps, die integrierte Funktionen duplizieren (z. B. ein Pulsmesser ohne Mehrwert), sind verboten.