WatchKit — vad är det, ramverket för Apple Watch och watchOS

Vad är WatchKit och hur fungerar det?

WatchKit — Apples ramverk som tillhandahåller API för att skapa applikationer på Apple Watch. Från och med watchOS 2 (2015) körs WatchKit-applikationer direkt på klockan, inte på iPhone, vilket gör att de kan bearbeta data och visa gränssnitt utan permanent anslutning till telefonen. Innan detta i watchOS 1 kördes alla applikationer på iPhone och klockan var endast en fjärrkontroll för fjärrvisning, vilket orsakade betydande UI-fördröjningar.

Den moderna WatchKit-arkitekturen inkluderar två komponenter: WatchKit App (Storyboard + resurser på klockan) och WatchKit Extension (kod som exekveras på klockan). Användaren installerar båda komponenterna via App Store vid installation av den överordnade iOS-applikationen. WatchKit tillhandahåller integration med systemfunktioner: notifikationer (via UNUserNotificationCenter), komplikationer (data på urtavlan), Workout API och HealthKit.

Enligt Counterpoint Research (2025) innehar Apple Watch 52 % av den globala smartklocksmarknaden, och den genomsnittliga användaren installerar 6–8 tredjepartsapplikationer med WatchKit eller SwiftUI. De mest populära kategorierna är fitness (56 %), hälsa (22 %), navigering (9 %) och verktyg (8 %).

WatchKit vs SwiftUI för watchOS

SwiftUI — Apples rekommenderade sätt att skapa gränssnitt för watchOS från och med watchOS 6. SwiftUI tillhandahåller deklarativ syntax och automatisk anpassning till skärmstorlekar. WatchKit förblir dock relevant för projekt som påbörjades före SwiftUIs ankomst, för användning av specifika element (WKInterfaceMap, WKInterfaceMovie) och i fall där stöd för watchOS-versioner lägre än 6 krävs.

WatchKit-gränssnitt: WKInterfaceController och element

WKInterfaceController — baskklassen för att hantera skärmen i WatchKit. Den ansvarar för livscykeln: initiering (awake(withContext:)), visning (willActivate), försvinnande (didDeactivate) och kontextöverföring mellan kontroller. Varje appskärm representeras av en separat underklass av WKInterfaceController, kopplad till Storyboard via Interface Builder. Navigering kan vara hierarkisk (push) eller modal (present).

WatchKit tillhandahåller en uppsättning gränssnittselement med prefixet WKInterface: WKInterfaceLabel (text), WKInterfaceButton (knapp), WKInterfaceTable (tabell), WKInterfaceImage (bild), WKInterfaceMap (karta) och WKInterfaceGroup (behållare med rundade hörn och bakgrund). Alla element fungerar asynkront — UI-ändringar köas och tillämpas av systemet mellan renderingscykler, vilket garanterar stabila 30 FPS på klockans skärm.

Grundläggande WKInterfaceController

class MainInterfaceController: WKInterfaceController {
    @IBOutlet weak var titleLabel: WKInterfaceLabel!
    @IBOutlet weak var actionButton: WKInterfaceButton!
    
    override func awake(with context: Any?) {
        super.awake(with: context)
        titleLabel.setText("Hej, Watch!")
    }
    
    override func willActivate() {
        super.willActivate()
        actionButton.setTitle("Starta")
    }
    
    @IBAction func didTapButton() {
        pushController(withName: "DetailController", context: nil)
    }
}

WCSession: kommunikation mellan Watch och iPhone

WCSession — den centrala klassen för tvåvägskommunikation mellan Apple Watch och iPhone via Bluetooth eller Wi-Fi. Sessionen möjliggör överföring av små dataordböcker (updateApplicationContext), skicka meddelanden med omedelbart svar (sendMessage), överföra filer (transferFile) och synkronisera komplexa objekt (transferUserInfo). WCSession fungerar asynkront och väljer automatiskt den optimala kommunikationskanalen.

För att använda WCSession måste sessionen aktiveras på båda enheterna. Watch-appen skapar WCSession i metoden willActivate(), och iOS-appen i AppDelegate eller SceneDelegate. Efter aktivering av sessionen synkroniserar enheterna automatiskt kontexten när det är möjligt. Det är viktigt att hantera delegaten WCSessionDelegate för att ta emot inkommande data och övervaka anslutningsstatus.

Exempel på WCSession på Watch-sidan

class SessionManager: NSObject, WCSessionDelegate {
    private let session = WCSession.default
    
    func activate() {
        session.delegate = self
        session.activate()
    }
    
    func sendDataToPhone(key: String, value: Any) {
        guard session.isReachable else { return }
        session.sendMessage([key: value],
            replyHandler: { response in
                print("Response: \(response)")
            },
            errorHandler: { error in
                print("Error: \(error.localizedDescription)")
            }
        )
    }
    
    func session(_ session: WCSession,
               didReceiveMessage message: [String: Any],
               replyHandler: @escaping ([String: Any]) -> Void) {
        handleIncomingData(message)
        replyHandler(["status": "ok"])
    }
}

Complications: data på urtavlan

Complications — små dataelement som visas på Apple Watch-urtavlan och ger snabb åtkomst till information utan att öppna appen. WatchKit tillhandahåller CLKComplicationDataSource — ett protokoll vars implementering gör att appen kan leverera data för komplikationer. Urtavlan bestämmer själv vilka positioner som är tillgängliga — runda (circular), rektangulära (rectangular), hörn (corner) eller modulära (modular).

Utvecklaren kan leverera komplikationer för tre storleksfamiljer: CLKComplicationFamily — circularSmall, extraLarge, graphicCircular, graphicRectangular, graphicCorner, graphicBezel, modularSmall, modularLarge och utilitarianSmall/Large. Varje familj har sina egna dimensioner och visningsformat. Appen kan stödja flera familjer, men minst två rekommenderas — grafisk och modulär.

Exempel på CLKComplicationDataSource

class ComplicationController: NSObject, CLKComplicationDataSource {
    func getCurrentTimelineEntry(
        for complication: CLKComplication,
        withHandler handler: @escaping (CLKComplicationTimelineEntry?) -> Void
    ) {
        let template = CLKComplicationTemplateModularSmallSimpleText()
        template.textProvider = CLKSimpleTextProvider(text: "96%")
        let entry = CLKComplicationTimelineEntry(
            date: Date(),
            complicationTemplate: template
        )
        handler(entry)
    }
}

Exempel på WatchKit-app i Swift

Att skapa en WatchKit-app börjar med att lägga till WatchKit App Target i Xcode. Xcode genererar Interface.storyboard med en初始 kontroller och kopplar den automatiskt till klassen InterfaceController. Utvecklaren lägger till UI-element via Interface Builder och skapar IBOutlet för interaktion från kod. Nedan — ett komplett exempel på en kontroller med en tabell över data mottagen från iPhone via WCSession.

class ItemRowController: NSObject {
    @IBOutlet weak var itemLabel: WKInterfaceLabel!
    
    func configure(with text: String) {
        itemLabel.setText(text)
    }
}

class ListController: WKInterfaceController {
    @IBOutlet weak var itemsTable: WKInterfaceTable!
    private var items: [String] = []
    
    override func awake(with context: Any?) {
        super.awake(with: context)
        items = context as? [String] ?? []
        
        itemsTable.setNumberOfRows(items.count,
            withRowType: "ItemRow")
        for i in 0..if let row = itemsTable
                .rowController(at: i) as? ItemRowController {
                row.configure(with: items[i])
            }
        }
    }
}

Workout API för fitnessappar

Workout API — en uppsättning WatchKit-klasser för att skapa fitnessappar som kan köra träningspass på Apple Watch i bakgrunden. API:et ger tillgång till sensorer: accelerometer, gyroskop, pulsmätare (via HKHealthStore) och GPS (på Watch-modeller med GPS). Träningspass startas via HKWorkoutSession från HealthKit och pulsdata uppdateras i realtid via HKSampleQuery.

Den viktigaste fördelen med Workout API är möjligheten att arbeta i bakgrunden. När ett träningspass är aktivt pausar watchOS inte appen när armen sänks — sensorerna fortsätter att samla in data och appen kan visa puls, distans, tempo och andra mätvärden. Efter träningspasset synkroniseras data med Health App på iPhone via HealthKit, vilket säkerställer en enhetlig fitnessprofil för användaren.

Starta träningspass med sensorer

class WorkoutManager: NSObject {
    private let healthStore = HKHealthStore()
    private var session: HKWorkoutSession!
    
    func startWorkout(activityType: HKWorkoutActivityType) {
        let config = HKWorkoutConfiguration()
        config.activityType = activityType
        config.locationType = .outdoor
        
        session = try! HKWorkoutSession(
            healthStore: healthStore,
            configuration: config
        )
        session.startActivity(with: Date())
    }
    
    func stopWorkout() {
        session.stopActivity(with: Date())
        session.end()
    }
}