watchOS: grunderna i utveckling för Apple Watch med SwiftUI

Vad är watchOS?

watchOS — operativsystemet för Apples smartklockor, baserat på XNU Darwin-kärnan. Först lanserat den 24 april 2015 tillsammans med Apple Watch Series 0. Systemet är byggt på samma arkitektur som iOS, men optimerat för en liten skärm (1,5 till 1,9 tum), begränsat minne (upp till 1 GB RAM i Series 9) och minimal energiförbrukning.

Enligt StatCounter (2026) har watchOS cirka 55% av marknaden för operativsystem för smartklockor, före Wear OS och proprietära system från kinesiska tillverkare. Apple släpper årligen stora watchOS-uppdateringar och stöder klockor upp till 5 år från lansering.

Nyckelfunktionen hos watchOS — beroendet av iPhone. De flesta appar använder Watch Connectivity för datasynkronisering. Från watchOS 6 kan klockor installera appar direkt från App Store, men full autonomi utan iPhone stöds först från watchOS 9.

Historia över watchOS-versioner

Den första versionen Watch OS 1.0 stödde inte tredjepartsappar — endast förinstallerade Apple-appar. watchOS 2 (2015) öppnade SDK för utvecklare. watchOS 3 (2016) snabbade upp appstart 7 gånger. watchOS 6 (2019) introducerade App Store på klockan. watchOS 9 (2022) lade till läkemedel och förbättrad sömnspårning. watchOS 10 (2023) blev den största gränssnittsuppdateringen sedan lanseringen.

Arkitektur för watchOS

Arkitekturen för watchOS består av tre lager som isolerar hårdvaran från användarappar. Till skillnad från iOS använder watchOS en komponentbaserad metod: en app består av två mål — ett tillägg (extension) och en värd på iPhone.

Kärna och systemtjänster

Det nedre lagret — modifierad XNU-kärna med drivrutiner för S4/S5/S6/S7/S8/S9 Apple-chips. Apple Watch Series 9 använder S9 SiP med 5,6 miljarder transistorer och 4-kärnig Neural Engine. Systemtjänster inkluderar Core Bluetooth, Watch Connectivity, HealthKit och Core Motion. Alla bakgrundsuppgifter hanteras av BGTaskScheduler — en systemplanerare som optimerar energiförbrukningen.

WatchKit — applikationslagret

WatchKit — ramverk för att skapa watchOS-appars gränssnitt. Inkluderar WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel och WKInterfaceButton. Från watchOS 6 rekommenderar Apple SwiftUI istället för WatchKit. SwiftUI ger samma möjligheter men med deklarativ syntax och automatisk anpassning till skärmstorlek: 38 mm (272×340), 42 mm (312×390), 40 mm (324×394), 44 mm (368×448), 45 mm (396×484), 49 mm (410×502 i Apple Watch Ultra).

Bakgrundslägen och energiförbrukning

watchOS begränsar appars bakgrundsarbete för att spara batteri. Tillgängliga bakgrundslägen: Workout (träning), HealthKit (hälsoövervakning), Location (geolokalisering), Audio (ljudspelare) och Complication (data på urtavlan). Varje läge kräver en separat capability i entitlements. Typisk energiförbrukning: aktiv app — 50-80 mA, bakgrundsläge — 5-15 mA, standbyläge — 1-3 mA.

import BackgroundTasks
import WatchKit

/// Planering av bakgrundsdatauppdatering på 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)
            }
        }
    }
}

/// Registrering av bakgrundsuppgift i 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 garanterar att bakgrundsuppgifter utförs vid optimala tillfällen — när klockan laddas och är ansluten till iPhone. WKExtensionDelegate bearbetar inkommande bakgrundsuppgifter och uppdaterar data på urtavlan. ComplicationController.reloadComplications uppdaterar widgets på den valda urtavlan.

watchOS 10: Smart Stack och Double Tap

watchOS 10 — den största gränssnittsuppdateringen i plattformens historia, släppt i september 2023. Systemet gick från hierarkisk navigering till innehållsorienterad navigering: huvudskärmen blev Smart Stack — en intelligent widgetstack som ersatte appdockan.

Smart Stack

Smart Stack — en vertikal lista med widgets som visas under urtavlan. Widgetar rangordnas efter kontext: på morgonen visas väder och kalender, under dagen — aktivitet och påminnelser, på kvällen — meditation och förberedelse för sömn. Utvecklare kan lägga till anpassade widgets via WidgetKit för watchOS, med samma API:er som för iOS 17.

Double Tap

Double Tap — gesten att föra ihop pekfinger och tumme, som känns igen av accelerometern och gyroskopet utan att röra skärmen. I Apple Watch Series 9 och Ultra 2 utförs gesten på hårdvarunivå via Neural Engine. Utvecklaren får händelsen via UIDoubleTapGestureRecognizer eller via SwiftUI-modifieraren .onTapGesture(count: 2). Gesten kräver ingen kalibrering och fungerar i vilken handorientering som helst.

Nya API:er för utvecklare

watchOS 10 introducerade: SwiftUI Animation med stöd för Spring- och Keyframe-animationer, MapKit för att visa kartor på klockan, VideoPlayer för uppspelning av korta videor (upp till 30 sekunder), förbättrad VoiceOver med gester och ett nytt navigeringsparadigm NavigationStack istället för NavigationView.

SwiftUI för Apple Watch

SwiftUI — det huvudsakliga ramverket för att utveckla gränssnitt på watchOS. Apple rekommenderar SwiftUI för alla nya projekt från watchOS 7. SwiftUI för klockor använder samma principer som för iOS, men med watchOS-specifika modifierare och komponenter.

WatchOS-specifika SwiftUI-komponenter

SwiftUI för watchOS inkluderar: TabView med page-stil för svepning mellan skärmar, DigitalCrownRotation för bearbetning av kronrotation, SceneStorage för att spara tillstånd mellan starter, WKNotificationScene för anpassade notiser och ComplicationDescriptor för data på urtavlan.

import SwiftUI
import HealthKit

/// watchOS-app för pulsmätning
@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("Puls", systemImage: "heart.fill") }

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

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

Appen HeartMonitorApp demonstrerar den typiska strukturen för en watchOS-app i SwiftUI: TabView med page-stil för svepning mellan skärmar, integration med HealthKit för realtidsavläsning av puls, WKNotificationScene för bearbetning av notiser. SymbolEffect med pulse-animation använder Neural Engines hårdvaruacceleration för smidig animation utan CPU-belastning.

Digital Crown och gester

Digital Crown — kronan på sidopanelen av Apple Watch. SwiftUI tillhandahåller DigitalCrownRotation för att binda ett värde till kronans rotation. Modifieraren tar emot en bindning, ett intervall och ett steg. Gester: tap (tryck), longPress (långt tryck), swipe (svep) och pan (drag) — alla standard för SwiftUI och anpassade till klockans skärmstorlek.

WatchKit och komponenter i watchOS-appar

WatchKit — det ursprungliga ramverket för watchOS som använder UIKit-metoden. Även om Apple rekommenderar SwiftUI förblir WatchKit relevant för äldre projekt och specifika uppgifter: komplexa animationer på WKInterfaceGroup och integration med SiriKit.

Struktur för en watchOS-app

En watchOS-app består av två mål: WatchKit Extension (logik och gränssnitt) och iOS Companion App (inställningar och synkronisering). Från Xcode 15 är det möjligt att skapa en fristående app utan iOS-kompanjon. Gränssnittet beskrivs i Interface.storyboard (WatchKit) eller programmatiskt via SwiftUI.

Complications — data på urtavlan

Complication — en widget som visar data på Apple Watch-urtavlan. Utvecklaren implementerar protokollet CLKComplicationDataSource och tillhandahåller mallar för olika urtavletyper (circular, rectangular, modular, extraLarge). watchOS 10 stöder ComplicationDescriptor — ett förenklat API för SwiftUI. Data uppdateras via Background Tasks med en period på upp till 30 minuter.

Integration med iPhone via Watch Connectivity

Watch Connectivity — ramverk för datautbyte mellan Apple Watch och iPhone via Bluetooth eller Wi-Fi. Det enda sättet att kommunicera mellan parade enheter. WCSession — den centrala klassen som hanterar sessionen. iOS-appen och watchOS-tillägget måste implementera WCSessionDelegate.

Metoder för dataöverföring

Watch Connectivity tillhandahåller fyra metoder för dataöverföring: sendMessage — omedelbar sändning med bekräftelse (fungerar bara när båda apparna är aktiva), transferUserInfo — bakgrundsleverans av en dataordbok, transferFile — filöverföring med metadata, updateApplicationContext — synkronisering av gemensamt tillstånd. Alla metoder garanterar leverans vid återupprättande av anslutning.

import WatchConnectivity

/// Synkroniseringshanterare mellan iPhone och 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: — Skicka data från iPhone till klockan
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // Om klockan inte är tillgänglig — spara i kontexten
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("Send error: \(error.localizedDescription)")
        }
    }

    // MARK: — Ta emot data på klockan
    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)")
    }

    // Krävs inte på watchOS men obligatoriskt för protokollet
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

ConnectivityManager implementerar en singleton för arbete med WCSession. sendWorkoutData kontrollerar isReachable: om klockan är aktiv skickas data omedelbart via sendMessage; om inte — sparas de i applicationContext för fördröjd leverans. onReceiveMessage på mottagarsidan bearbetar inkommande meddelanden och meddelar appen via NotificationCenter.

Filutbyte och synkronisering

transferFile möjliggör överföring av stora datamängder: bilder, ljudfiler, arkiv. Maximal filstorlek — 100 MB. Filer sparas i Inbox-katalogen på den mottagande enheten. transferUserInfo är lämplig för JSON-data upp till 100 KB. Alla metoder fungerar i bakgrunden: om enheten inte är tillgänglig hamnar överföringen i kö och återupptas automatiskt när anslutningen återställs.

Publicering av watchOS-appar

Publicering av en watchOS-app följer samma regler som iOS: ett Apple Developer Program-abonnemang ($99/år) och godkännande av App Review krävs. Appen laddas upp till App Store Connect som en del av iOS-appen eller som en fristående app.

Bygga och distribuera

En watchOS-app kan levereras på två sätt: som ett inbyggt tillägg till iOS-appen (iOS app bundle innehåller watchOS .app) eller som en fristående app (laddas ner och fungerar utan iPhone). För fristående läge krävs WKRunsIndependently = YES i Info.plist. Storleken på watchOS-appen är begränsad till 50 MB för nedladdning via mobilnätet.

App Review-krav

Särskilda krav för watchOS: appen måste fungera korrekt utan aktiv iPhone (om den deklareras som fristående), gränssnittet måste vara läsbart utan förstoring, alla interaktiva element — minst 44 punkter i storlek. Appar som duplicerar inbyggd funktionalitet (t.ex. pulsmätare utan mervärde) är förbjudna.