Watch App: co to je, vývoj pro Apple Watch a Wear OS

Co je Watch App

Watch App — je aplikace určená pro práci na nositelných zařízeních: Apple Watch (watchOS) a chytré hodinky na Wear OS. Hlavní rozdíl oproti mobilní aplikaci — faktor formy. Obrazovka hodinek má úhlopříčku 1.5–2 palce (oproti 6–7 palcům u smartphonu), což omezuje množství současně zobrazovaných informací. Interakce s aplikací je krátká — uživatel zkontroluje čas, oznámení, puls nebo kroky během 5–15 sekund, poté sklopí ruku.

Klíčové scénáře Watch App: fitness tracker (kroky, puls, kalorie, spánek), oznámení (zprávy, hovory, kalendář), rychlé akce (spuštění časovače, hlasová odpověď na zprávu, ovládání hudby), společník (dálkové ovládání kamery, klíče od auta, NFC platby). Podle Counterpoint Research (2026) globální trh chytrých hodinek přesahuje 150 milionů zařízení ročně, z čehož Apple Watch zaujímá 35%, Wear OS — 20%, zbytek — Fitbit, Garmin a další.

Omezení Watch App: malá obrazovka (do 2 palců), omezená výdrž baterie (do 18–24 hodin), absence plnohodnotné klávesnice (pouze hlasový vstup nebo diktování), limit pro úlohy na pozadí (watchOS — do 10 minut, Wear OS — do 5 minut), nutnost synchronizace s telefonem pro většinu funkcí. Od watchOS 6 (2019) a Wear OS 3 (2022) mohou aplikace pracovat autonomně přes LTE modul bez párování s telefonem.

Apple Watch: watchOS a SwiftUI

watchOS — operační systém Apple pro chytré hodinky, založený na iOS a používající stejné frameworky (Foundation, UIKit v upravené verzi, SwiftUI). Vývoj probíhá v Xcode ve Swiftu. Hlavní UI framework — SwiftUI, který poskytuje komponenty specifické pro watchOS: TabView s karuselem, NavigationStack, digitální korunku (Digital Crown) přes DigitalCrownModifier, menu dlouhého stisku.

Navigace na watchOS je založena na hierarchickém paradigmatu. Hlavní prvky: hierarchický zásobník (NavigationStack s automatickým návratem), modální prezentace (sheet), stránková navigace (page-based přes TabView s .tabViewStyle(.page)), kontextové nabídky při dlouhém stisku. Digital Crown umožňuje posouvání obsahu a změnu hodnot. Gesta: klepnutí, dlouhý stisk, přejetí, Force Touch (do watchOS 7), otočení Digital Crown.

Klíčové frameworky watchOS: HealthKit (přístup k datům o zdraví — puls, kroky, spánek, EKG), CoreMotion (akcelerometr, gyroskop), WatchConnectivity (výměna dat s iPhonem), ClockKit (komplikace na ciferníku), BackgroundTasks (aktualizace na pozadí do 10 minut), ARKit (FaceTime s efekty na Series 9+). Watch App může být plnohodnotná (samostatná aplikace v docku) nebo rozšíření (současně s iOS verzí).

Wear OS: Kotlin a Compose

Wear OS — platforma Googlu pro chytré hodinky, založená na Androidu. Moderní vývoj probíhá v Kotlinu s Jetpack Compose for Wear OS — sadou komponent optimalizovaných pro kulaté obrazovky: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. Na rozdíl od mobilního Compose, Wear OS používá vlastní modifikátory: scrollable pro vertikální posouvání, swipable pro přejetí, RotaryInput pro ovládání korunky.

Navigace na Wear OS používá boční panel (SwipeToDismiss) a obrazovky-karty. Hlavní prvky: SwipeDismissableNavHost (navigace s návratem přejetím), pozicování obrazovek (ScalingLazyColumn pro seznamy), horizontální karusel (Carousel), ciferník (WatchFace přes WatchFaceService). Google doporučuje používat boční přejetí pro návrat a vertikální posouvání pro seznamy. Tlačítko napájení na hodinkách otevře seznam posledních aplikací.

Zdraví a senzory na Wear OS: Health Services API (kroky, puls, kalorie, spánek, SpO2 přes poskytovatele dat), SensorManager (akcelerometr, gyroskop, barometr, magnetometr), Location Services (GPS přes FusedLocationProvider). Wear OS 5+ podporuje sledování běhu, chůze, cyklistiky a plavání s automatickým rozpoznáním typu aktivity. Data se synchronizují s Google Fit přes Health Connect.

Příklad kódu: Swift pro Apple Watch

Podívejme se na aplikaci pro sledování pulsu na Apple Watch pomocí SwiftUI a HealthKit.

import SwiftUI
import HealthKit

// Datový model pro puls
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

// ViewModel pro 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)
    }
}

// Hlavní obrazovka
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)
    }
}

Klíčové body: HKHealthStore žádá o přístup k datům HealthKit; HKObserverQuery informuje o změnách pulsu v reálném čase; HKSampleQuery získává poslední hodnotu. Watch App automaticky aktualizuje UI při změně currentHeartRate díky @Observable. HealthKit zpracovává data lokálně na zařízení — požadavky na server nejsou nutné.

Příklad kódu: Kotlin pro Wear OS

Obdobná aplikace pro Wear OS v Kotlinu s Jetpack Compose a 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 pro přístup k senzorům
        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 = "Puls",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

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

Klíčové komponenty Wear OS: Scaffold s TimeText a Vignette pro typické rozložení; modifikátor .scrollable() pro kompatibilitu s kulatou obrazovkou; HealthService (Horologist) pro přístup k senzorům pulsu. Jetpack Compose for Wear OS automaticky přizpůsobuje rozhraní pro kulaté a čtvercové obrazovky — vývojář nemusí ručně řešit různé faktory formy.