Watch App: co to jest, tworzenie dla Apple Watch i Wear OS

Co to jest Watch App

Watch App — to aplikacja przeznaczona do pracy na urządzeniach noszonych: Apple Watch (watchOS) i smartwatchach na Wear OS. Główna różnica w stosunku do aplikacji mobilnej — czynnik formy. Ekran zegarka ma przekątną 1.5–2 cala (w porównaniu z 6–7 cali u smartfona), co ogranicza ilość jednocześnie wyświetlanych informacji. Interakcja z aplikacją jest krótka — użytkownik sprawdza czas, powiadomienie, puls lub kroki w ciągu 5–15 sekund, po czym opuszcza rękę.

Kluczowe scenariusze Watch App: tracker fitness (kroki, puls, kalorie, sen), powiadomienia (wiadomości, połączenia, kalendarz), szybkie akcje (uruchomienie timera, odpowiedź na wiadomość głosem, sterowanie muzyką), kompanion (pilot do aparatu, kluczyki do samochodu, płatności NFC). Według Counterpoint Research (2026), globalny rynek smartwatchy przekracza 150 mln urządzeń rocznie, z czego Apple Watch zajmuje 35%, Wear OS — 20%, reszta — Fitbit, Garmin i inne.

Ograniczenia Watch App: mały ekran (do 2 cali), ograniczony czas pracy na baterii (do 18–24 godzin), brak pełnoprawnej klawiatury (tylko wprowadzanie głosowe lub dyktowanie), limit zadań w tle (watchOS — do 10 minut, Wear OS — do 5 minut), konieczność synchronizacji z telefonem dla większości funkcji. Od watchOS 6 (2019) i Wear OS 3 (2022) aplikacje mogą działać autonomicznie przez moduł LTE bez pary z telefonem.

Apple Watch: watchOS i SwiftUI

watchOS — system operacyjny Apple dla smartwatchy, bazujący na iOS i używający tych samych frameworków (Foundation, UIKit w wersji adaptowanej, SwiftUI). Tworzenie odbywa się w Xcode w języku Swift. Główny framework UI — SwiftUI, który dostarcza komponenty specyficzne dla watchOS: TabView z karuzelą, NavigationStack, cyfrową koronkę (Digital Crown) przez DigitalCrownModifier, menu długiego naciśnięcia.

Nawigacja na watchOS opiera się na paradygmacie hierarchicznym. Główne elementy: stos hierarchiczny (NavigationStack z automatycznym powrotem), prezentacje modalne (sheet), nawigacja stronicowa (page-based przez TabView z .tabViewStyle(.page)), menu kontekstowe przy długim naciśnięciu. Digital Crown pozwala przewijać treść i zmieniać wartości. Gesty: tap, długie naciśnięcie, przesunięcie, Force Touch (do watchOS 7), obrót Digital Crown.

Kluczowe frameworki watchOS: HealthKit (dostęp do danych zdrowia — puls, kroki, sen, EKG), CoreMotion (akcelerometr, żyroskop), WatchConnectivity (wymiana danych z iPhone), ClockKit (komplikacje na tarczę zegarka), BackgroundTasks (aktualizacje w tle do 10 minut), ARKit (FaceTime z efektami na Series 9+). Watch App może być pełnoprawną (osobna aplikacja w docku) lub rozszerzeniem (jednocześnie z wersją iOS).

Wear OS: Kotlin i Compose

Wear OS — platforma Google dla smartwatchy, oparta na Androidzie. Nowoczesne tworzenie odbywa się w Kotlin z Jetpack Compose for Wear OS — zestawem komponentów zoptymalizowanych pod okrągłe ekrany: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. W przeciwieństwie do mobilnego Compose, Wear OS używa własnych modyfikatorów: scrollable do przewijania pionowego, swipable do przesuwania, RotaryInput do sterowania pokrętłem.

Nawigacja na Wear OS używa panelu bocznego (SwipeToDismiss) i ekranów-kart. Główne elementy: SwipeDismissableNavHost (nawigacja z powrotem przez przesunięcie), pozycjonowanie ekranów (ScalingLazyColumn dla list), karuzela pozioma (Carousel), tarcza zegarka (WatchFace przez WatchFaceService). Google zaleca używanie bocznego przesunięcia do powrotu i przewijania pionowego dla list. Przycisk zasilania na zegarku otwiera listę ostatnich aplikacji.

Zdrowie i czujniki na Wear OS: Health Services API (kroki, puls, kalorie, sen, SpO2 przez dostawców danych), SensorManager (akcelerometr, żyroskop, barometr, magnetometr), Location Services (GPS przez FusedLocationProvider). Wear OS 5+ obsługuje śledzenie biegania, chodzenia, jazdy na rowerze i pływania z automatycznym określaniem typu aktywności. Dane synchronizują się z Google Fit przez Health Connect.

Przykład kodu: Swift dla Apple Watch

Rozpatrzmy aplikację do śledzenia tętna na Apple Watch z użyciem SwiftUI i HealthKit.

import SwiftUI
import HealthKit

// Model danych tętna
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

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

// Ekran główny
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)
    }
}

Kluczowe punkty: HKHealthStore żąda dostępu do danych HealthKit; HKObserverQuery powiadamia o zmianach tętna w czasie rzeczywistym; HKSampleQuery pobiera ostatnią wartość. Watch App automatycznie aktualizuje UI przy zmianie currentHeartRate dzięki @Observable. HealthKit przetwarza dane lokalnie na urządzeniu — zapytania do serwera nie są wymagane.

Przykład kodu: Kotlin dla Wear OS

Analogiczna aplikacja dla Wear OS w Kotlin z Jetpack Compose i 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 dostępu do czujników
        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 = "Tętno",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

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

Kluczowe komponenty Wear OS: Scaffold z TimeText i Vignette dla typowego układu; .scrollable() modyfikator dla kompatybilności z okrągłym ekranem; HealthService (Horologist) do dostępu do czujników tętna. Jetpack Compose for Wear OS automatycznie adaptuje interfejs pod okrągłe i kwadratowe ekrany — programista nie musi obsługiwać różnych form faktorów ręcznie.