watchOS: a fejlesztés alapjai Apple Watchhoz SwiftUI-val

Mi az a watchOS?

watchOS — az Apple okosóráinak operációs rendszere, amely az XNU Darwin magra épül. Először 2015. április 24-én adták ki az Apple Watch Series 0-val együtt. A rendszer ugyanarra az architektúrára épül, mint az iOS, de kis kijelzőhöz (1,5-1,9 hüvelyk), korlátozott memóriához (Series 9-ben 1 GB RAM-ig) és minimális energiafogyasztáshoz optimalizálták.

A StatCounter (2026) adatai szerint a watchOS az okosóra operációs rendszerek piacának körülbelül 55%-át birtokolja, megelőzve a Wear OS-t és a kínai gyártók saját rendszereit. Az Apple évente ad ki nagy watchOS frissítéseket, támogatva az órákat a megjelenéstől számított 5 évig.

A watchOS kulcsjellemzője — az iPhone-tól való függőség. A legtöbb alkalmazás a Watch Connectivity-t használja az adatok szinkronizálásához. A watchOS 6-tól kezdve az órák közvetlenül az App Store-ból telepíthetnek alkalmazásokat, de a teljes autonómia iPhone nélkül csak a watchOS 9-től támogatott.

A watchOS verzióinak története

Az első Watch OS 1.0 verzió nem támogatott harmadik féltől származó alkalmazásokat — csak az Apple előre telepített alkalmazásait. A watchOS 2 (2015) megnyitotta az SDK-t a fejlesztők számára. A watchOS 3 (2016) 7-szeresére gyorsította az alkalmazások indítását. A watchOS 6 (2019) bevezette az App Store-t az órán. A watchOS 9 (2022) gyógyszereket és továbbfejlesztett alváskövetést adott hozzá. A watchOS 10 (2023) a megjelenés óta a legnagyobb felületfrissítés lett.

A watchOS architektúrája

A watchOS architektúrája három rétegből áll, amelyek elkülönítik a hardvert a felhasználói alkalmazásoktól. Az iOS-szel ellentétben a watchOS komponens alapú megközelítést használ: az alkalmazás két célból áll — egy kiterjesztésből (extension) és egy gazdagépből az iPhone-on.

Mag és rendszerszolgáltatások

Az alsó réteg — módosított XNU mag az S4/S5/S6/S7/S8/S9 Apple chipek illesztőprogramjaival. Az Apple Watch Series 9-ben S9 SiP-t használnak 5,6 milliárd tranzisztorral és 4 magos Neural Engine-nel. A rendszerszolgáltatások közé tartozik a Core Bluetooth, Watch Connectivity, HealthKit és Core Motion. Az összes háttérfeladatot a BGTaskScheduler — az energiafogyasztást optimalizáló rendszerütemező — kezeli.

WatchKit — alkalmazásréteg

WatchKit — keretrendszer watchOS alkalmazások felületeinek létrehozásához. Tartalmazza a WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel és WKInterfaceButton elemeket. A watchOS 6-tól kezdve az Apple a WatchKit helyett a SwiftUI-t ajánlja. A SwiftUI ugyanazokat a képességeket nyújtja, de deklaratív szintaxissal és automatikus képernyőméret-adaptációval: 38 mm (272×340), 42 mm (312×390), 40 mm (324×394), 44 mm (368×448), 45 mm (396×484), 49 mm (410×502 Apple Watch Ultra esetén).

Háttérmódok és energiafogyasztás

A watchOS korlátozza az alkalmazások háttérműködését az akkumulátor kímélése érdekében. Elérhető háttérmódok: Workout (edzések), HealthKit (egészségmegfigyelés), Location (helymeghatározás), Audio (audiolejátszó) és Complication (adatok az óralapon). Minden mód külön capability-t igényel az entitlements-ben. Tipikus energiafogyasztás: aktív alkalmazás — 50-80 mA, háttérmód — 5-15 mA, készenlét — 1-3 mA.

import BackgroundTasks
import WatchKit

/// Háttéraktualizálás ütemezése watchOS-en
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)
            }
        }
    }
}

/// Háttérfeladat regisztrálása a WKExtensionDelegate-ben
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)
            }
        }
    }
}

A BGTaskScheduler garantálja, hogy a háttérfeladatok optimális pillanatokban — amikor az óra a töltőn van és csatlakozik az iPhone-hoz — hajtódnak végre. A WKExtensionDelegate feldolgozza a bejövő háttérfeladatokat és frissíti az adatokat az óralapon. A ComplicationController.reloadComplications frissíti a widgeteket a kiválasztott óralapon.

watchOS 10: Smart Stack és Double Tap

watchOS 10 — a platform történetének legnagyobb felületfrissítése, amelyet 2023 szeptemberében adtak ki. A rendszer a hierarchikus navigációról a tartalomközpontú navigációra váltott: a főképernyő a Smart Stack — az alkalmazásdokkot felváltó intelligens widget halmaz lett.

Smart Stack

Smart Stack — az óralap alatt megjelenő widgetek függőleges listája. A widgetek kontextus szerint rangsorolódnak: reggel az időjárás és naptár, napközben az aktivitás és emlékeztetők, este a meditáció és alvásra való felkészülés jelenik meg. A fejlesztő egyedi widgeteket adhat hozzá a WidgetKit segítségével watchOS-hez, ugyanazokat az API-kat használva, mint az iOS 17 esetében.

Double Tap

Double Tap — a mutató- és hüvelykujj összeérintésének gesztusa, amelyet a gyorsulásmérő és giroszkóp ismer fel a képernyő érintése nélkül. Az Apple Watch Series 9 és Ultra 2 készülékekben a gesztus hardver szinten, a Neural Engine segítségével történik. A fejlesztő az eseményt a UIDoubleTapGestureRecognizer vagy a SwiftUI .onTapGesture(count: 2) módosító segítségével kapja meg. A gesztus nem igényel kalibrálást, és a kéz bármely irányában működik.

Új API-k fejlesztőknek

A watchOS 10 bevezette: SwiftUI Animation Spring és Keyframe animációk támogatásával, MapKit térképek megjelenítéséhez az órán, VideoPlayer rövid videók (30 másodpercig) lejátszásához, továbbfejlesztett VoiceOver gesztusokkal és új navigációs paradigmát, a NavigationStack-et a NavigationView helyett.

SwiftUI Apple Watchhoz

SwiftUI — a fő keretrendszer a watchOS felületek fejlesztéséhez. Az Apple a SwiftUI-t ajánlja minden új projekthez a watchOS 7-től kezdve. A SwiftUI az órákhoz ugyanazokat az elveket használja, mint az iOS esetében, de watchOS-specifikus módosítókkal és komponensekkel.

WatchOS-specifikus SwiftUI komponensek

A SwiftUI watchOS-hez a következőket tartalmazza: TabView page-stílussal a képernyők közötti lapozáshoz, DigitalCrownRotation a korona forgatásának kezeléséhez, SceneStorage az állapot mentéséhez indítások között, WKNotificationScene egyedi értesítésekhez és ComplicationDescriptor az óralap adataihoz.

import SwiftUI
import HealthKit

/// watchOS alkalmazás pulzusfigyeléshez
@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("Pulzus", systemImage: "heart.fill") }

            StepsView()
                .tabItem { Label("Lépések", systemImage: "figure.walk") }

            SettingsView()
                .tabItem { Label("Beállítások", 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)
        }
    }
}

A HeartMonitorApp alkalmazás egy tipikus watchOS alkalmazás szerkezetét mutatja be SwiftUI-ban: TabView page-stílussal a képernyők közötti lapozáshoz, integráció a HealthKit-kel a valós idejű pulzusméréshez, WKNotificationScene az értesítések feldolgozásához. A SymbolEffect pulse animációval a Neural Engine hardveres gyorsítását használja a sima animációhoz CPU-terhelés nélkül.

Digital Crown és gesztusok

Digital Crown — az Apple Watch oldalsó paneljén található korona. A SwiftUI DigitalCrownRotation funkciót biztosít az érték koronaforgatáshoz kötéséhez. A módosító egy binding-ot, tartományt és lépést fogad. Gesztusok: tap (érintés), longPress (hosszú nyomás), swipe (húzás) és pan (húzás) — mindegyik szabványos a SwiftUI-ban, és az óra képernyőméretéhez igazították.

WatchKit és a watchOS alkalmazás komponensei

WatchKit — az eredeti watchOS keretrendszer, amely a UIKit megközelítést használja. Bár az Apple a SwiftUI-t ajánlja, a WatchKit továbbra is releváns a régebbi projektek és speciális feladatok esetén: összetett animációk a WKInterfaceGroup-on és integráció a SiriKit-tel.

A watchOS alkalmazás szerkezete

A watchOS alkalmazás két célból áll: WatchKit Extension (logika és felület) és iOS Companion App (beállítások és szinkronizálás). Az Xcode 15-től kezdve lehetőség van önálló alkalmazás létrehozására iOS társ nélkül. A felületet az Interface.storyboard (WatchKit) vagy programozottan a SwiftUI segítségével írják le.

Complications — adatok az óralapon

Complication — widget, amely adatokat jelenít meg az Apple Watch óralapján. A fejlesztő implementálja a CLKComplicationDataSource protokollt, sablonokat biztosítva a különböző óralaptípusokhoz (circular, rectangular, modular, extraLarge). A watchOS 10 támogatja a ComplicationDescriptor-t — egyszerűsített API-t SwiftUI-hoz. Az adatok frissítése Background Tasks segítségével történik, legfeljebb 30 perces időközönként.

Integráció iPhone-nal Watch Connectivity-n keresztül

Watch Connectivity — keretrendszer az Apple Watch és iPhone közötti adatcseréhez Bluetooth-on vagy Wi-Fi-n keresztül. Az egyetlen kommunikációs mód a párosított eszközök között. A WCSession — a munkamenetet kezelő központi osztály. Az iOS alkalmazásnak és a watchOS kiterjesztésnek implementálnia kell a WCSessionDelegate-et.

Adatátviteli módszerek

A Watch Connectivity négy adatátviteli módszert kínál: sendMessage — azonnali küldés visszaigazolással (csak akkor működik, ha mindkét alkalmazás aktív), transferUserInfo — adatszótár háttérben történő kézbesítése, transferFile — fájlok átvitele metaadatokkal, updateApplicationContext — közös állapot szinkronizálása. Minden módszer garantálja a kézbesítést a kapcsolat helyreállításakor.

import WatchConnectivity

/// Szinkronizációs menedzser iPhone és Apple Watch között
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: — Adatok küldése iPhone-ról az órára
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // Ha az óra nem elérhető — mentés a kontextusba
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("Send error: \(error.localizedDescription)")
        }
    }

    // MARK: — Adatok fogadása az órán
    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 activated: \(activationState.rawValue)")
    }

    // Nem szükséges watchOS-en, de kötelező a protokollhoz
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

A ConnectivityManager egy szingletont implementál a WCSession-nal való munkához. A sendWorkoutData ellenőrzi az isReachable-t: ha az óra aktív, az adatok azonnal elküldésre kerülnek a sendMessage segítségével; ha nem — elmenti az applicationContext-be késleltetett kézbesítéshez. Az onReceiveMessage a fogadó oldalon feldolgozza a bejövő üzeneteket, és értesíti az alkalmazást a NotificationCenter-en keresztül.

Fájlcsere és szinkronizálás

A transferFile lehetővé teszi nagy mennyiségű adat átvitelét: képek, audio fájlok, archívumok. Maximális fájlméret — 100 MB. A fájlok a fogadó eszköz Inbox könyvtárába kerülnek. A transferUserInfo legfeljebb 100 KB-os JSON adatokhoz alkalmas. Minden módszer a háttérben működik: ha az eszköz nem elérhető, az átvitel sorba kerül, és a kapcsolat helyreállításakor automatikusan folytatódik.

watchOS alkalmazások közzététele

A watchOS alkalmazás közzététele ugyanazokra a szabályokra vonatkozik, mint az iOS esetében: Apple Developer Program előfizetés (99 USD/év) és az App Review moderálásán való átesés szükséges. Az alkalmazást az App Store Connect-be töltik fel az iOS alkalmazás részeként vagy önálló alkalmazásként.

Fordítás és terjesztés

A watchOS alkalmazás kétféleképpen szállítható: az iOS alkalmazás beépített kiterjesztéseként (iOS app bundle tartalmazza a watchOS .app fájlt) vagy önálló alkalmazásként (iPhone nélkül letöltődik és működik). Az önálló módhoz a WKRunsIndependently = YES beállítás szükséges az Info.plist-ben. A watchOS alkalmazás mérete mobilhálózaton történő letöltés esetén 50 MB-ra korlátozódik.

App Review követelmények

Különleges követelmények a watchOS esetében: az alkalmazásnak megfelelően kell működnie aktív iPhone nélkül (ha önállóként van deklarálva), a felületnek nagyítás nélkül olvashatónak kell lennie, minden interaktív elem mérete legalább 44 pont. Tilosak a beépített alkalmazások funkcionalitását megkettőző alkalmazások (pl. pulzusmérő hozzáadott érték nélkül).