Watch App: Was ist das, Entwicklung für Apple Watch und Wear OS

Was ist Watch App

Watch App ist eine Anwendung, die für den Betrieb auf tragbaren Geräten konzipiert ist: Apple Watch (watchOS) und Smartwatches mit Wear OS. Der Hauptunterschied zu einer mobilen App ist der Formfaktor. Der Bildschirm der Uhr hat eine Diagonale von 1,5–2 Zoll (gegenüber 6–7 Zoll bei einem Smartphone), was die Menge der gleichzeitig angezeigten Informationen einschränkt. Die Interaktion mit der App ist kurz — der Benutzer prüft Zeit, Benachrichtigung, Puls oder Schritte in 5–15 Sekunden und senkt dann die Hand.

Wichtige Watch App-Szenarien: Fitness-Tracker (Schritte, Puls, Kalorien, Schlaf), Benachrichtigungen (Nachrichten, Anrufe, Kalender), schnelle Aktionen (Timer starten, Nachricht per Sprache beantworten, Musik steuern), Begleiter (Kamera-Fernbedienung, Autoschlüssel, NFC-Zahlung). Laut Counterpoint Research (2026) übersteigt der weltweite Smartwatch-Markt 150 Millionen Geräte pro Jahr, davon Apple Watch 35%, Wear OS 20%, der Rest Fitbit, Garmin und andere.

Watch App-Einschränkungen: kleiner Bildschirm (bis 2 Zoll), begrenzte Akkulaufzeit (bis 18–24 Stunden), keine vollständige Tastatur (nur Spracheingabe oder Diktat), Hintergrundaufgaben-Limit (watchOS — bis 10 Minuten, Wear OS — bis 5 Minuten), Synchronisation mit dem Telefon für die meisten Funktionen erforderlich. Ab watchOS 6 (2019) und Wear OS 3 (2022) können Apps über das LTE-Modul autonom arbeiten, ohne mit einem Telefon gekoppelt zu sein.

Apple Watch: watchOS und SwiftUI

watchOS ist das Betriebssystem von Apple für Smartwatches, basierend auf iOS und unter Verwendung derselben Frameworks (Foundation, UIKit in adaptierter Version, SwiftUI). Die Entwicklung erfolgt in Xcode mit Swift. Das Haupt-UI-Framework ist SwiftUI, das watchOS-spezifische Komponenten bereitstellt: TabView mit Karussell, NavigationStack, Digital Crown über DigitalCrownModifier, Langdruck-Menü.

Navigation auf watchOS basiert auf einem hierarchischen Paradigma. Hauptelemente: hierarchischer Stapel (NavigationStack mit automatischer Rückkehr), modale Präsentationen (sheet), seitenbasierte Navigation (über TabView mit .tabViewStyle(.page)), Kontextmenüs bei langem Druck. Die Digital Crown ermöglicht das Scrollen von Inhalten und das Ändern von Werten. Gesten: Tippen, langes Drücken, Wischen, Force Touch (bis watchOS 7), Drehen der Digital Crown.

Wichtige watchOS-Frameworks: HealthKit (Zugriff auf Gesundheitsdaten — Puls, Schritte, Schlaf, EKG), CoreMotion (Beschleunigungsmesser, Gyroskop), WatchConnectivity (Datenaustausch mit iPhone), ClockKit (Komplikationen auf dem Zifferblatt), BackgroundTasks (Hintergrundaktualisierungen bis 10 Minuten), ARKit (FaceTime-Effekte auf Series 9+). Eine Watch App kann vollständig (eigenständige App im Dock) oder eine Erweiterung (gleichzeitig mit der iOS-Version) sein.

Wear OS: Kotlin und Compose

Wear OS ist die Google-Plattform für Smartwatches, basierend auf Android. Die moderne Entwicklung erfolgt in Kotlin mit Jetpack Compose for Wear OS — einer Reihe von Komponenten, die für runde Bildschirme optimiert sind: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. Im Gegensatz zu mobilem Compose verwendet Wear OS eigene Modifikatoren: scrollable für vertikales Scrollen, swipable zum Wischen, RotaryInput für die Kronensteuerung.

Navigation auf Wear OS verwendet eine Seitenleiste (SwipeToDismiss) und Kartenbildschirme. Hauptelemente: SwipeDismissableNavHost (Navigation mit Zurückwischen), Bildschirmpositionierung (ScalingLazyColumn für Listen), horizontales Karussell (Carousel), Zifferblatt (WatchFace über WatchFaceService). Google empfiehlt, seitliches Wischen zum Zurückgehen und vertikales Scrollen für Listen zu verwenden. Der Einschaltknopf der Uhr öffnet die Liste der letzten Apps.

Gesundheit und Sensoren auf Wear OS: Health Services API (Schritte, Puls, Kalorien, Schlaf, SpO2 über Datenanbieter), SensorManager (Beschleunigungsmesser, Gyroskop, Barometer, Magnetometer), Location Services (GPS über FusedLocationProvider). Wear OS 5+ unterstützt die Verfolgung von Laufen, Gehen, Radfahren und Schwimmen mit automatischer Aktivitätserkennung. Daten werden über Health Connect mit Google Fit synchronisiert.

Codebeispiel: Swift für Apple Watch

Betrachten wir eine Pulsmess-App für die Apple Watch mit SwiftUI und HealthKit.

import SwiftUI
import HealthKit

// Datenmodell für Puls
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

// ViewModel für HealthKit
@Observable
final class HealthViewModel {
    private let healthStore = HKHealthStore()
    var currentHeartRate: Double = 0
    var isAuthorized: Bool = false

    func requestAuthorization() {
        guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)
        else { return }
        let types = Set([heartRateType])
        healthStore.requestAuthorization(toShare: nil, read: types) { success, _ in
            Task { @MainActor in
                self.isAuthorized = success
                if success { self.startHeartRateQuery() }
            }
        }
    }

    func startHeartRateQuery() {
        guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)
        else { return }
        let query = HKObserverQuery(
            sampleType: heartRateType, predicate: nil
        ) { [weak self] _, _, _ in
            self?.fetchLatestHeartRate()
        }
        healthStore.execute(query)
    }

    private func fetchLatestHeartRate() {
        guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)
        else { return }
        let sort = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)
        let query = HKSampleQuery(
            sampleType: heartRateType, predicate: nil,
            limit: 1, sortDescriptors: [sort]
        ) { _, samples, _ in
            guard let sample = samples?.first as? HKQuantitySample else { return }
            let bpm = sample.quantity.doubleValue(for: HKUnit.count().unitDivided(by: .minute()))
            Task { @MainActor in
                self.currentHeartRate = bpm
            }
        }
        healthStore.execute(query)
    }
}

// Hauptbildschirm
struct HeartRateView: View {
    @State private var viewModel = HealthViewModel()

    var body: some View {
        VStack {
            Image(systemName: "heart.fill")
                .foregroundColor(.red)
                .font(.largeTitle)

            Text("\(Int(viewModel.currentHeartRate))")
                .font(.system(size: 60, weight: .bold, design: .rounded))
                .foregroundColor(.red)

            Text("BPM")
                .font(.caption)
                .foregroundColor(.secondary)
        }
        .padding()
        .onAppear(perform: viewModel.requestAuthorization)
    }
}

Wichtige Punkte: HKHealthStore fordert Zugriff auf HealthKit-Daten an; HKObserverQuery benachrichtigt über Pulsänderungen in Echtzeit; HKSampleQuery ruft den letzten Wert ab. Die Watch App aktualisiert die UI automatisch, wenn sich currentHeartRate dank @Observable ändert. HealthKit verarbeitet Daten lokal auf dem Gerät — Serveranfragen sind nicht erforderlich.

Codebeispiel: Kotlin für Wear OS

Ähnliche App für Wear OS in Kotlin mit Jetpack Compose und Health Services API.

// MainActivity.kt
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.wear.compose.material.*
import androidx.wear.compose.foundation.arc.BasicArcParams
import com.google.android.horologist.health.HealthService

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            WearAppTheme {
                HeartRateScreen()
            }
        }
    }
}

@Composable
fun HeartRateScreen() {
    var heartRate by remember { mutableIntStateOf(0) }
    var isConnected by remember { mutableStateOf(false) }

    LaunchedEffect(Unit) {
        // HealthService — API für Sensorzugriff
        val healthService = HealthService()
        healthService.connect().onSuccess {
            isConnected = true
        }
    }

    Scaffold(
        timeText = { TimeText() },
        vignette = { Vignette(vignettePosition = VignettePosition.TopAndBottom) }
    ) {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .scrollable(state = ScrollState),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {
            Icon(
                imageVector = Icons.Filled.Favorite,
                contentDescription = "Herzfrequenz",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

            Text(
                text = heartRate.toString(),
                style = MaterialTheme.typography.display1
            )
            Text(
                text = "BPM",
                style = MaterialTheme.typography.caption2
            )
        }
    }
}

Wichtige Wear OS-Komponenten: Scaffold mit TimeText und Vignette für ein Standard-Layout; .scrollable()-Modifikator für Rundbildschirm-Kompatibilität; HealthService (Horologist) für Puls-Sensor-Zugriff. Jetpack Compose for Wear OS passt die Oberfläche automatisch an runde und eckige Bildschirme an — der Entwickler muss nicht manuell mit verschiedenen Formfaktoren umgehen.