Watch App: mi ez, fejlesztés Apple Watch és Wear OS rendszerekre

Mi az a Watch App

Watch App — olyan alkalmazás, amelyet hordható eszközökön való működésre terveztek: Apple Watch (watchOS) és Wear OS okosórák. A fő különbség a mobilalkalmazáshoz képest — a formai tényező. Az óra képernyőjének átlója 1.5–2 hüvelyk (szemben a smartphone 6–7 hüvelykesével), ami korlátozza az egyidejűleg megjeleníthető információ mennyiségét. Az alkalmazással való interakció rövid — a felhasználó 5–15 másodperc alatt ellenőrzi az időt, értesítést, pulzust vagy lépéseket, majd leengedi a karját.

A Watch App kulcsfontosságú forgatókönyvei: fitneszkövető (lépések, pulzus, kalória, alvás), értesítések (üzenetek, hívások, naptár), gyors műveletek (időzítő indítása, hangüzenetre válasz, zenevezérlés), társ (kamera távirányító, autókulcs, NFC-fizetés). A Counterpoint Research (2026) szerint az okosórák globális piaca meghaladja az évi 150 millió eszközt, amelyből az Apple Watch 35%-ot, a Wear OS 20%-ot tesz ki, a többi — Fitbit, Garmin és mások.

A Watch App korlátozásai: kis képernyő (2 hüvelykig), korlátozott akkumulátor-üzemidő (18–24 óráig), teljes billentyűzet hiánya (csak hangbemenet vagy diktálás), háttérfeladatok korlátja (watchOS — 10 percig, Wear OS — 5 percig), szinkronizálás szükségessége a telefonnal a legtöbb funkcióhoz. A watchOS 6-tól (2019) és Wear OS 3-tól (2022) kezdve az alkalmazások autonóm módon működhetnek LTE-modulon keresztül, telefon párosítása nélkül.

Apple Watch: watchOS és SwiftUI

watchOS — az Apple operációs rendszere okosórákhoz, amely iOS-re épül és ugyanazokat a keretrendszereket használja (Foundation, UIKit adaptált verzióban, SwiftUI). A fejlesztés Xcode-ban, Swift nyelven történik. A fő UI keretrendszer — SwiftUI, amely watchOS-specifikus komponenseket biztosít: TabView karusszellel, NavigationStack, digitális korona (Digital Crown) DigitalCrownModifier-en keresztül, hosszú lenyomás menü.

Navigáció a watchOS-en hierarchikus paradigmára épül. Fő elemek: hierarchikus verem (NavigationStack automatikus visszatéréssel), modális prezentációk (sheet), oldal alapú navigáció (page-based TabView-en keresztül .tabViewStyle(.page) beállítással), helyi menük hosszú lenyomásra. A Digital Crown lehetővé teszi a tartalom görgetését és értékek módosítását. Mozdulatok: koppintás, hosszú lenyomás, húzás, Force Touch (watchOS 7-ig), Digital Crown elforgatása.

Kulcsfontosságú watchOS keretrendszerek: HealthKit (hozzáférés egészségügyi adatokhoz — pulzus, lépések, alvás, EKG), CoreMotion (gyorsulásmérő, giroszkóp), WatchConnectivity (adatcsere iPhone-nal), ClockKit (komplikációk a számlapon), BackgroundTasks (háttérfrissítések 10 percig), ARKit (FaceTime effektusokkal Series 9+ készülékeken). A Watch App lehet teljes értékű (külön alkalmazás a dokkban) vagy kiterjesztés (egyidejűleg az iOS verzióval).

Wear OS: Kotlin és Compose

Wear OS — a Google platformja okosórákhoz, Android alapokon. A modern fejlesztés Kotlin-ban történik Jetpack Compose for Wear OS-sel — egy kerek képernyőkre optimalizált komponenskészlettel: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. A mobil Compose-tól eltérően a Wear OS saját módosítókat használ: scrollable függőleges görgetéshez, swipable húzáshoz, RotaryInput a korona vezérléséhez.

Navigáció a Wear OS-en oldalsó panelt (SwipeToDismiss) és kártyaképernyőket használ. Fő elemek: SwipeDismissableNavHost (navigáció húzással való visszatéréssel), képernyők pozícionálása (ScalingLazyColumn listákhoz), vízszintes karusszel (Carousel), számlap (WatchFace WatchFaceService-en keresztül). A Google az oldalsó húzást ajánlja visszatéréshez és a függőleges görgetést listákhoz. Az óra bekapcsológombja megnyitja a legutóbbi alkalmazások listáját.

Egészség és érzékelők a Wear OS-en: Health Services API (lépések, pulzus, kalória, alvás, SpO2 adatszolgáltatókon keresztül), SensorManager (gyorsulásmérő, giroszkóp, barométer, magnetométer), Location Services (GPS FusedLocationProvider-en keresztül). A Wear OS 5+ támogatja a futás, gyaloglás, kerékpározás és úszás követését a tevékenység típusának automatikus felismerésével. Az adatok a Google Fit-tel szinkronizálódnak a Health Connect-en keresztül.

Kódpélda: Swift Apple Watch-hoz

Vizsgáljunk meg egy pulzuskövető alkalmazást Apple Watch-on SwiftUI és HealthKit használatával.

import SwiftUI
import HealthKit

// Adatmodell a pulzushoz
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

// ViewModel a HealthKit-hez
@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)
    }
}

// Főképernyő
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)
    }
}

Kulcsfontosságú pontok: HKHealthStore hozzáférést kér a HealthKit adatokhoz; HKObserverQuery valós időben értesít a pulzus változásairól; HKSampleQuery lekéri az utolsó értéket. A Watch App automatikusan frissíti a UI-t a currentHeartRate változásakor az @Observable-nek köszönhetően. A HealthKit az adatokat lokálisan dolgozza fel az eszközön — szerverlekérdezések nem szükségesek.

Kódpélda: Kotlin Wear OS-hez

Hasonló alkalmazás Wear OS-hez Kotlin-ban Jetpack Compose-szal és Health Services API-val.

// 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 az érzékelők eléréséhez
        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 = "Pulzus",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

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

A Wear OS kulcsfontosságú komponensei: Scaffold TimeText-tel és Vignette-tel tipikus elrendezéshez; .scrollable() módosító a kerek képernyővel való kompatibilitáshoz; HealthService (Horologist) a pulzusérzékelők eléréséhez. A Jetpack Compose for Wear OS automatikusan adaptálja a felületet kerek és négyzet alakú képernyőkhöz — a fejlesztőnek nem kell manuálisan kezelnie a különböző formai tényezőket.