WatchKit — co to je, framework Apple Watch a watchOS

Co je WatchKit a jak funguje?

WatchKit — framework Apple, který poskytuje API pro vytváření aplikací na Apple Watch. Počínaje watchOS 2 (2015) běží aplikace WatchKit přímo na hodinkách, nikoli na iPhone, což jim umožňuje zpracovávat data a zobrazovat rozhraní bez trvalého připojení k telefonu. Před tím v watchOS 1 všechny aplikace běžely na iPhone a hodinky byly pouze dálkovým ovladačem pro vzdálené zobrazení, což způsobovalo výrazné zpoždění UI.

Moderní architektura WatchKit zahrnuje dvě komponenty: WatchKit App (Storyboard + zdroje na hodinkách) a WatchKit Extension (kód spouštěný na hodinkách). Uživatel instaluje obě komponenty přes App Store při instalaci nadřazené iOS aplikace. WatchKit zajišťuje integraci se systémovými funkcemi: oznámeními (přes UNUserNotificationCenter), komplikacemi (data na číselníku), Workout API a HealthKit.

Podle Counterpoint Research (2025) zaujímá Apple Watch 52 % globálního trhu chytrých hodinek a průměrný uživatel instaluje 6–8 aplikací třetích stran pomocí WatchKit nebo SwiftUI. Nejoblíbenější kategorie jsou fitness (56 %), zdraví (22 %), navigace (9 %) a nástroje (8 %).

WatchKit vs SwiftUI pro watchOS

SwiftUI — doporučený způsob Apple pro vytváření rozhraní pro watchOS od watchOS 6. SwiftUI poskytuje deklarativní syntaxi a automatickou adaptaci na velikosti obrazovky. WatchKit však zůstává relevantní pro projekty zahájené před příchodem SwiftUI, pro použití specifických prvků (WKInterfaceMap, WKInterfaceMovie) a v případech, kde je vyžadována podpora watchOS verzí nižších než 6.

Rozhraní WatchKit: WKInterfaceController a prvky

WKInterfaceController — základní třída pro správu obrazovky ve WatchKit. Zodpovídá za životní cyklus: inicializaci (awake(withContext:)), zobrazení (willActivate), zmizení (didDeactivate) a předávání kontextu mezi kontrolery. Každá obrazovka aplikace je reprezentována samostatnou podtřídou WKInterfaceController, propojenou se Storyboard přes Interface Builder. Navigace může být hierarchická (push) nebo modální (present).

WatchKit poskytuje sadu prvků rozhraní s předponou WKInterface: WKInterfaceLabel (text), WKInterfaceButton (tlačítko), WKInterfaceTable (tabulka), WKInterfaceImage (obrázek), WKInterfaceMap (mapa) a WKInterfaceGroup (kontejner se zaoblenými rohy a pozadím). Všechny prvky pracují asynchronně — změny UI jsou zařazeny do fronty a systém je aplikuje mezi cykly vykreslování, což zaručuje stabilních 30 FPS na obrazovce hodinek.

Základní 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("Ahoj, Watch!")
    }
    
    override func willActivate() {
        super.willActivate()
        actionButton.setTitle("Start")
    }
    
    @IBAction func didTapButton() {
        pushController(withName: "DetailController", context: nil)
    }
}

WCSession: komunikace mezi Watch a iPhone

WCSession — centrální třída pro obousměrnou komunikaci mezi Apple Watch a iPhone přes Bluetooth nebo Wi-Fi. Relace umožňuje přenos malých slovníků dat (updateApplicationContext), odesílání zpráv s okamžitou odpovědí (sendMessage), přenos souborů (transferFile) a synchronizaci komplexních objektů (transferUserInfo). WCSession pracuje asynchronně a automaticky vybírá optimální komunikační kanál.

Pro použití WCSession je nutné aktivovat relaci na obou zařízeních. Watch aplikace vytváří WCSession v metodě willActivate(), iOS aplikace v AppDelegate nebo SceneDelegate. Po aktivaci relace zařízení automaticky synchronizují kontext, kdykoli je to možné. Je důležité zpracovávat delegáta WCSessionDelegate pro příjem příchozích dat a sledování stavu připojení.

Příklad WCSession na straně Watch

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 na číselníku hodinek

Complications — malé datové prvky, které se zobrazují na číselníku Apple Watch a poskytují rychlý přístup k informacím bez otevření aplikace. WatchKit poskytuje CLKComplicationDataSource — protokol, jehož implementace umožňuje aplikaci dodávat data pro komplikace. Ciferník sám rozhoduje, které pozice jsou dostupné — kruhové (circular), obdélníkové (rectangular), rohové (corner) nebo modulární (modular).

Vývojář může poskytovat komplikace pro tři velikosti rodin: CLKComplicationFamily — circularSmall, extraLarge, graphicCircular, graphicRectangular, graphicCorner, graphicBezel, modularSmall, modularLarge a utilitarianSmall/Large. Každá rodina má své vlastní rozměry a formát zobrazení. Aplikace může podporovat více rodin, ale doporučují se alespoň dvě — grafická a modulární.

Příklad 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)
    }
}

Příklad aplikace WatchKit ve Swiftu

Vytvoření aplikace WatchKit začíná přidáním WatchKit App Target v Xcode. Xcode vygeneruje Interface.storyboard s počátečním kontrolerem a automaticky jej propojí s třídou InterfaceController. Vývojář přidá prvky UI přes Interface Builder a vytvoří IBOutlet pro interakci z kódu. Níže — kompletní příklad kontroleru s tabulkou dat přijatých z iPhone přes 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 pro fitness aplikace

Workout API — sada tříd WatchKit pro vytváření fitness aplikací, které mohou spouštět tréninky na Apple Watch na pozadí. API poskytuje přístup k senzorům: akcelerometru, gyroskopu, měřiči pulsu (přes HKHealthStore) a GPS (na modelech Watch s GPS). Tréninky se spouštějí přes HKWorkoutSession z HealthKit a data pulsu se aktualizují v reálném čase přes HKSampleQuery.

Klíčovou výhodou Workout API je možnost práce na pozadí. Když je trénink aktivní, watchOS nepozastavuje aplikaci při spuštění ruky — senzory pokračují ve sběru dat a aplikace může zobrazovat puls, vzdálenost, tempo a další metriky. Po dokončení tréninku jsou data synchronizována s Health App na iPhone přes HealthKit, což zajišťuje jednotný fitness profil uživatele.

Spuštění tréninku se senzory

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()
    }
}