watchOS: podstawy programowania dla Apple Watch z SwiftUI

Co to jest watchOS?

watchOS — system operacyjny dla inteligentnych zegarków Apple, oparty na jądrze XNU Darwin. Po raz pierwszy wydany 24 kwietnia 2015 wraz z Apple Watch Series 0. System zbudowany jest na tej samej architekturze co iOS, ale zoptymalizowany pod mały wyświetlacz (od 1,5 do 1,9 cala), ograniczoną pamięć (do 1 GB RAM w Series 9) i minimalne zużycie energii.

Według danych StatCounter (2026), watchOS zajmuje około 55% rynku systemów operacyjnych dla inteligentnych zegarków, wyprzedzając Wear OS i zastrzeżone systemy chińskich producentów. Apple wydaje główne aktualizacje watchOS corocznie, wspierając zegarki do 5 lat od momentu premiery.

Kluczowa cecha watchOS — zależność od iPhone. Większość aplikacji używa Watch Connectivity do synchronizacji danych. Od watchOS 6 zegarki mogą instalować aplikacje bezpośrednio z App Store, ale pełna niezależność bez iPhone jest obsługiwana dopiero od watchOS 9.

Historia wersji watchOS

Pierwsza wersja Watch OS 1.0 nie obsługiwała aplikacji firm trzecich — tylko preinstalowane aplikacje Apple. watchOS 2 (2015) otworzyła SDK dla programistów. watchOS 3 (2016) przyspieszyła uruchamianie aplikacji 7-krotnie. watchOS 6 (2019) wprowadziła App Store na zegarku. watchOS 9 (2022) dodała leki i ulepszone śledzenie snu. watchOS 10 (2023) stała się największą aktualizacją interfejsu od momentu premiery.

Architektura watchOS

Architektura watchOS składa się z trzech warstw izolujących sprzęt od aplikacji użytkownika. W przeciwieństwie do iOS, watchOS stosuje podejście komponentowe: aplikacja składa się z dwóch targetów — rozszerzenia (extension) i hosta na iPhone.

Jądro i usługi systemowe

Dolna warstwa — zmodyfikowane jądro XNU ze sterownikami dla układów S4/S5/S6/S7/S8/S9 Apple. W Apple Watch Series 9 zastosowano S9 SiP z 5,6 miliarda tranzystorów i 4-rdzeniowym Neural Engine. Usługi systemowe obejmują Core Bluetooth, Watch Connectivity, HealthKit i Core Motion. Wszystkie zadania w tle są zarządzane przez BGTaskScheduler — systemowy harmonogram optymalizujący zużycie energii.

WatchKit — warstwa aplikacji

WatchKit — framework do tworzenia interfejsów aplikacji watchOS. Obejmuje WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel i WKInterfaceButton. Od watchOS 6 Apple zaleca SwiftUI zamiast WatchKit. SwiftUI zapewnia te same możliwości, ale z deklaratywną składnią i automatyczną adaptacją do rozmiaru ekranu: 38 mm (272×340), 42 mm (312×390), 40 mm (324×394), 44 mm (368×448), 45 mm (396×484), 49 mm (410×502 w Apple Watch Ultra).

Tryby tła i zużycie energii

watchOS ogranicza pracę aplikacji w tle w celu oszczędzania baterii. Dostępne tryby tła: Workout (treningi), HealthKit (monitorowanie zdrowia), Location (geolokalizacja), Audio (odtwarzacz audio) i Complication (dane na tarczy zegarka). Każdy tryb wymaga osobnej capability w entitlements. Typowe zużycie energii: aktywna aplikacja — 50-80 mA, tryb tła — 5-15 mA, Standby — 1-3 mA.

import BackgroundTasks
import WatchKit

/// Planowanie aktualizacji danych w tle na watchOS
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)
            }
        }
    }
}

/// Rejestracja zadania w tle w WKExtensionDelegate
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)
            }
        }
    }
}

BGTaskScheduler gwarantuje, że zadania w tle są wykonywane w optymalnych momentach — gdy zegarek jest na ładowarce i podłączony do iPhone. WKExtensionDelegate obsługuje przychodzące zadania w tle i aktualizuje dane na tarczy zegarka. ComplicationController.reloadComplications odświeża widżety na wybranej tarczy zegarka.

watchOS 10: Smart Stack i Double Tap

watchOS 10 — największa aktualizacja interfejsu w historii platformy, wydana we wrześniu 2023 roku. System przeszedł od nawigacji hierarchicznej do nawigacji zorientowanej na treść: głównym ekranem stał się Smart Stack — inteligentny stos widżetów, który zastąpił dok aplikacji.

Smart Stack

Smart Stack — pionowa lista widżetów wyświetlana pod tarczą zegarka. Widżety są rankingowane według kontekstu: rano pokazywana jest pogoda i kalendarz, w ciągu dnia — aktywność i przypomnienia, wieczorem — medytacja i przygotowanie do snu. Deweloper może dodawać niestandardowe widżety przez WidgetKit dla watchOS, używając tych samych API co dla iOS 17.

Double Tap

Double Tap — gest złączenia palca wskazującego i kciuka, rozpoznawany przez akcelerometr i żyroskop bez dotykania ekranu. W Apple Watch Series 9 i Ultra 2 gest jest wykonywany na poziomie sprzętowym przez Neural Engine. Deweloper otrzymuje zdarzenie przez UIDoubleTapGestureRecognizer lub przez modyfikator SwiftUI .onTapGesture(count: 2). Gest nie wymaga kalibracji i działa w dowolnej orientacji ręki.

Nowe API dla programistów

watchOS 10 wprowadziła: SwiftUI Animation z obsługą animacji Spring i Keyframe, MapKit do wyświetlania map na zegarku, VideoPlayer do odtwarzania krótkich filmów (do 30 sekund), ulepszony VoiceOver z gestami oraz nową paradygmat nawigacji NavigationStack zamiast NavigationView.

SwiftUI dla Apple Watch

SwiftUI — główny framework do tworzenia interfejsów na watchOS. Apple zaleca SwiftUI dla wszystkich nowych projektów od watchOS 7. SwiftUI dla zegarków używa tych samych zasad co dla iOS, ale z modyfikatorami i komponentami specyficznymi dla watchOS.

Komponenty SwiftUI specyficzne dla watchOS

SwiftUI dla watchOS obejmuje: TabView ze stylem page do przesuwania między ekranami, DigitalCrownRotation do obsługi obracania koronką, SceneStorage do zapisywania stanu między uruchomieniami, WKNotificationScene dla niestandardowych powiadomień i ComplicationDescriptor dla danych na tarczy zegarka.

import SwiftUI
import HealthKit

/// Aplikacja watchOS do monitorowania tętna
@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("Tętno", systemImage: "heart.fill") }

            StepsView()
                .tabItem { Label("Kroki", systemImage: "figure.walk") }

            SettingsView()
                .tabItem { Label("Ustawienia", 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)
        }
    }
}

Aplikacja HeartMonitorApp demonstruje typową strukturę aplikacji watchOS w SwiftUI: TabView ze stylem page do przesuwania między ekranami, integrację z HealthKit do odczytu tętna w czasie rzeczywistym, WKNotificationScene do obsługi powiadomień. SymbolEffect z animacją pulse wykorzystuje sprzętowe przyspieszenie Neural Engine do płynnej animacji bez obciążania CPU.

Digital Crown i gesty

Digital Crown — koronka na bocznej ściance Apple Watch. SwiftUI udostępnia DigitalCrownRotation do przypisania wartości do obrotu koronką. Modyfikator przyjmuje binding, zakres i krok. Gesty: tap (dotknięcie), longPress (długie naciśnięcie), swipe (przesunięcie) i pan (przeciąganie) — wszystkie standardowe dla SwiftUI i dostosowane do rozmiaru ekranu zegarka.

WatchKit i komponenty aplikacji watchOS

WatchKit — oryginalny framework dla watchOS, wykorzystujący podejście UIKit. Mimo że Apple zaleca SwiftUI, WatchKit pozostaje aktualny dla projektów starszych i specyficznych zadań: złożonych animacji na WKInterfaceGroup i integracji z SiriKit.

Struktura aplikacji watchOS

Aplikacja na watchOS składa się z dwóch targetów: WatchKit Extension (logika i interfejs) oraz iOS Companion App (ustawienia i synchronizacja). Od Xcode 15 możliwe jest tworzenie aplikacji standalone bez kompana iOS. Interfejs opisuje się w Interface.storyboard (WatchKit) lub programowo przez SwiftUI.

Complications — dane na tarczy zegarka

Complication — widżet wyświetlający dane na tarczy Apple Watch. Deweloper implementuje protokół CLKComplicationDataSource, dostarczając szablony dla różnych typów tarcz (circular, rectangular, modular, extraLarge). watchOS 10 obsługuje ComplicationDescriptor — uproszczone API dla SwiftUI. Dane są aktualizowane przez Background Tasks z okresem do 30 minut.

Integracja z iPhone przez Watch Connectivity

Watch Connectivity — framework do wymiany danych między Apple Watch a iPhone przez Bluetooth lub Wi-Fi. Jedyny sposób komunikacji między sparowanymi urządzeniami. WCSession — centralna klasa zarządzająca sesją. Aplikacja iOS i rozszerzenie watchOS muszą implementować WCSessionDelegate.

Metody przesyłania danych

Watch Connectivity udostępnia cztery metody przesyłania danych: sendMessage — natychmiastowe wysyłanie z potwierdzeniem (działa tylko gdy obie aplikacje są aktywne), transferUserInfo — dostarczanie słownika danych w tle, transferFile — przesyłanie plików z metadanymi, updateApplicationContext — synchronizacja wspólnego stanu. Wszystkie metody gwarantują dostarczenie po wznowieniu połączenia.

import WatchConnectivity

/// Menedżer synchronizacji między iPhone a Apple Watch
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: — Wysyłanie danych z iPhone na zegarek
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // Jeśli zegarek jest niedostępny — zapisujemy w kontekście
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("Send error: \(error.localizedDescription)")
        }
    }

    // MARK: — Odbieranie danych na zegarku
    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)")
    }

    // Niewymagane na watchOS, ale obowiązkowe dla protokołu
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

ConnectivityManager implementuje singleton do pracy z WCSession. sendWorkoutData sprawdza isReachable: jeśli zegarek jest aktywny, dane są wysyłane natychmiast przez sendMessage; jeśli nie — zapisywane w applicationContext do opóźnionego dostarczenia. onReceiveMessage po stronie odbiorcy obsługuje przychodzące wiadomości i powiadamia aplikację przez NotificationCenter.

Wymiana plików i synchronizacja

transferFile umożliwia przesyłanie dużych ilości danych: obrazy, pliki audio, archiwa. Maksymalny rozmiar pliku — 100 MB. Pliki są zapisywane w katalogu Inbox na urządzeniu odbierającym. transferUserInfo nadaje się do danych JSON do 100 KB. Wszystkie metody działają w tle: jeśli urządzenie jest niedostępne, transmisja jest kolejkowana i automatycznie wznawiana po przywróceniu połączenia.

Publikowanie aplikacji watchOS

Publikowanie aplikacji watchOS podlega tym samym zasadom co iOS: wymagana jest subskrypcja Apple Developer Program (99 USD/rok) i przejście moderacji App Review. Aplikacja jest przesyłana do App Store Connect jako część aplikacji iOS lub jako aplikacja standalone.

Budowa i dystrybucja

Aplikacja watchOS może być dostarczana na dwa sposoby: jako wbudowane rozszerzenie aplikacji iOS (pakiet iOS app bundle zawiera watchOS .app) lub jako aplikacja standalone (pobierana i działająca bez iPhone). Dla trybu standalone wymagane jest WKRunsIndependently = YES w Info.plist. Rozmiar aplikacji watchOS jest ograniczony do 50 MB przy pobieraniu przez sieć komórkową.

Wymagania App Review

Szczególne wymagania dla watchOS: aplikacja musi działać poprawnie bez aktywnego iPhone (jeśli zadeklarowana jako standalone), interfejs musi być czytelny bez powiększania, wszystkie elementy interaktywne — co najmniej 44 punkty rozmiaru. Zabronione są aplikacje powielające funkcjonalność wbudowanych (np. pulsometr bez dodatkowej wartości).