Watch App: vad är det, utveckling för Apple Watch och Wear OS

Vad är Watch App

Watch App — är en applikation designad för att fungera på bärbara enheter: Apple Watch (watchOS) och smartklockor på Wear OS. Huvudskillnaden från en mobilapp — formfaktorn. Klockans skärm har en diagonal på 1,5–2 tum (jämfört med 6–7 tum på en smartphone), vilket begränsar mängden information som visas samtidigt. Interaktionen med appen är kort — användaren kollar tid, avisering, puls eller steg inom 5–15 sekunder och sänker sedan armen.

Nyckelscenarier för Watch App: fitnesstracker (steg, puls, kalorier, sömn), aviseringar (meddelanden, samtal, kalender), snabba åtgärder (starta timer, röstsvar på meddelande, styra musik), följeslagare (fjärrkontroll för kamera, bilnycklar, NFC-betalning). Enligt Counterpoint Research (2026) överstiger den globala smartklocksmarknaden 150 miljoner enheter per år, varav Apple Watch står för 35%, Wear OS — 20%, resten — Fitbit, Garmin och andra.

Begränsningar för Watch App: liten skärm (upp till 2 tum), begränsad batteritid (upp till 18–24 timmar), inget fullständigt tangentbord (endast röstinmatning eller diktering), gräns för bakgrundsuppgifter (watchOS — upp till 10 minuter, Wear OS — upp till 5 minuter), behov av synkronisering med telefon för de flesta funktioner. Från watchOS 6 (2019) och Wear OS 3 (2022) kan appar fungera autonomt via LTE-modul utan parkoppling med telefon.

Apple Watch: watchOS och SwiftUI

watchOS — Apples operativsystem för smartklockor, baserat på iOS och använder samma ramverk (Foundation, UIKit i anpassad version, SwiftUI). Utveckling sker i Xcode i Swift. Huvud-UI-ramverket — SwiftUI, som tillhandahåller watchOS-specifika komponenter: TabView med karusell, NavigationStack, digital krona (Digital Crown) via DigitalCrownModifier, långtryckningsmeny.

Navigering på watchOS bygger på hierarkiskt paradigm. Huvudelement: hierarkisk stack (NavigationStack med automatisk återgång), modal presentation (sheet), sidbaserad navigering (page-based via TabView med .tabViewStyle(.page)), snabbmenyer vid lång tryckning. Digital Crown möjliggör rullning av innehåll och ändring av värden. Gester: tryck, lång tryckning, svepning, Force Touch (fram till watchOS 7), rotation av Digital Crown.

Nyckelramverk för watchOS: HealthKit (åtkomst till hälsodata — puls, steg, sömn, EKG), CoreMotion (accelerometer, gyroskop), WatchConnectivity (datautbyte med iPhone), ClockKit (komplikationer på urtavlan), BackgroundTasks (bakgrundsuppdateringar upp till 10 minuter), ARKit (FaceTime med effekter på Series 9+). Watch App kan vara fullständig (separat app i dockan) eller tillägg (samtidigt med iOS-versionen).

Wear OS: Kotlin och Compose

Wear OS — Googles plattform för smartklockor, baserad på Android. Modern utveckling sker i Kotlin med Jetpack Compose for Wear OS — en uppsättning komponenter optimerade för runda skärmar: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. Till skillnad från mobil Compose använder Wear OS egna modifierare: scrollable för vertikal rullning, swipable för svepning, RotaryInput för kontroll av kronan.

Navigering på Wear OS använder sidopanel (SwipeToDismiss) och skärmkort. Huvudelement: SwipeDismissableNavHost (navigering med återgång genom svepning), positionering av skärmar (ScalingLazyColumn för listor), horisontell karusell (Carousel), urtavla (WatchFace via WatchFaceService). Google rekommenderar att använda sidosvepning för återgång och vertikal rullning för listor. Strömknappen på klockan öppnar listan över senaste appar.

Hälsa och sensorer på Wear OS: Health Services API (steg, puls, kalorier, sömn, SpO2 via dataleverantörer), SensorManager (accelerometer, gyroskop, barometer, magnetometer), Location Services (GPS via FusedLocationProvider). Wear OS 5+ stödjer spårning av löpning, promenad, cykling och simning med automatisk upptäckt av aktivitetstyp. Data synkroniseras med Google Fit via Health Connect.

Kodexempel: Swift för Apple Watch

Låt oss titta på en app för pulsspårning på Apple Watch med SwiftUI och HealthKit.

import SwiftUI
import HealthKit

// Datamodell för puls
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

// ViewModel för 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)
    }
}

// Huvudskärm
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)
    }
}

Nyckelpunkter: HKHealthStore begär åtkomst till HealthKit-data; HKObserverQuery meddelar om förändringar i puls i realtid; HKSampleQuery hämtar det senaste värdet. Watch App uppdaterar automatiskt UI när currentHeartRate ändras tack vare @Observable. HealthKit behandlar data lokalt på enheten — serverförfrågningar krävs inte.

Kodexempel: Kotlin för Wear OS