WatchKit — co to jest, framework Apple Watch i watchOS

Czym jest WatchKit i jak działa?

WatchKit — framework Apple, który udostępnia API do tworzenia aplikacji na Apple Watch. Począwszy od watchOS 2 (2015), aplikacje WatchKit działają bezpośrednio na zegarku, a nie na iPhone, co pozwala im przetwarzać dane i wyświetlać interfejs bez stałego połączenia z telefonem. Wcześniej w watchOS 1 wszystkie aplikacje działały na iPhone, a zegarek był jedynie pilotem zdalnego wyświetlania, co powodowało znaczne opóźnienia w UI.

Nowoczesna architektura WatchKit obejmuje dwa komponenty: WatchKit App (Storyboard + zasoby na zegarku) i WatchKit Extension (kod wykonywany na zegarku). Użytkownik instaluje oba komponenty przez App Store podczas instalacji nadrzędnej aplikacji iOS. WatchKit zapewnia integrację z funkcjami systemowymi: powiadomieniami (przez UNUserNotificationCenter), komplikacjami (dane na tarczy), Workout API i HealthKit.

Według danych Counterpoint Research (2025), Apple Watch zajmuje 52% światowego rynku inteligentnych zegarków, a przeciętny użytkownik instaluje 6–8 aplikacji firm trzecich z użyciem WatchKit lub SwiftUI. Najpopularniejsze kategorie to fitness (56%), zdrowie (22%), nawigacja (9%) i narzędzia (8%).

WatchKit vs SwiftUI dla watchOS

SwiftUI — zalecany przez Apple sposób tworzenia interfejsów dla watchOS począwszy od watchOS 6. SwiftUI oferuje deklaratywną składnię i automatyczną adaptację do rozmiarów ekranu. Jednak WatchKit pozostaje istotny dla projektów rozpoczętych przed pojawieniem się SwiftUI, do używania specyficznych elementów (WKInterfaceMap, WKInterfaceMovie) oraz w przypadkach wymagających wsparcia dla wersji watchOS starszych niż 6.

Interfejs WatchKit: WKInterfaceController i elementy

WKInterfaceController — klasa bazowa do zarządzania ekranem w WatchKit. Odpowiada za cykl życia: inicjalizację (awake(withContext:)), pojawienie się (willActivate), zniknięcie (didDeactivate) i przekazywanie kontekstu między kontrolerami. Każdy ekran aplikacji jest reprezentowany przez oddzielną podklasę WKInterfaceController, powiązaną ze Storyboard przez Interface Builder. Nawigacja może być hierarchiczna (push) lub modalna (present).

WatchKit udostępnia zestaw elementów interfejsu z prefiksem WKInterface: WKInterfaceLabel (tekst), WKInterfaceButton (przycisk), WKInterfaceTable (tabela), WKInterfaceImage (obraz), WKInterfaceMap (mapa) i WKInterfaceGroup (kontener z zaokrągleniami i tłem). Wszystkie elementy działają asynchronicznie — zmiany UI są kolejkowane i stosowane przez system między cyklami renderowania, co gwarantuje stabilne 30 FPS na ekranie zegarka.

Podstawowy 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("Cześć, Watch!")
    }
    
    override func willActivate() {
        super.willActivate()
        actionButton.setTitle("Start")
    }
    
    @IBAction func didTapButton() {
        pushController(withName: "DetailController", context: nil)
    }
}

WCSession: komunikacja między Watch a iPhone

WCSession — centralna klasa do dwukierunkowej komunikacji między Apple Watch a iPhone przez Bluetooth lub Wi-Fi. Sesja umożliwia przesyłanie małych słowników danych (updateApplicationContext), wysyłanie wiadomości z natychmiastową odpowiedzią (sendMessage), przesyłanie plików (transferFile) i synchronizację złożonych obiektów (transferUserInfo). WCSession działa asynchronicznie i automatycznie wybiera optymalny kanał komunikacji.

Aby używać WCSession, należy aktywować sesję na obu urządzeniach. Aplikacja Watch tworzy WCSession w metodzie willActivate(), a aplikacja iOS — w AppDelegate lub SceneDelegate. Po aktywacji sesji urządzenia automatycznie synchronizują kontekst, gdy jest to możliwe. Ważne jest obsłużenie delegata WCSessionDelegate do odbierania przychodzących danych i śledzenia stanu połączenia.

Przykład WCSession po stronie 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: dane na tarczy zegarka

Complications — to małe elementy danych wyświetlane na tarczy Apple Watch, zapewniające szybki dostęp do informacji bez otwierania aplikacji. WatchKit udostępnia CLKComplicationDataSource — protokół, którego implementacja pozwala aplikacji dostarczać dane dla komplikacji. Tarcza sama decyduje, które pozycje są dostępne — okrągłe (circular), prostokątne (rectangular), narożne (corner) lub modułowe (modular).

Deweloper może dostarczać komplikacje dla trzech rozmiarów rodzin: CLKComplicationFamily — circularSmall, extraLarge, graphicCircular, graphicRectangular, graphicCorner, graphicBezel, modularSmall, modularLarge oraz utilitarianSmall/Large. Każda rodzina ma swoje rozmiary i format wyświetlania. Aplikacja może obsługiwać wiele rodzin, ale zalecane są co najmniej dwie — graficzna i modułowa.

Przykład 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)
    }
}

Przykład aplikacji WatchKit w Swift

Tworzenie aplikacji WatchKit zaczyna się od dodania WatchKit App Target w Xcode. Xcode generuje Interface.storyboard z początkowym kontrolerem i automatycznie łączy go z klasą InterfaceController. Deweloper dodaje elementy UI przez Interface Builder i tworzy IBOutlet do interakcji z kodu. Poniżej — pełny przykład kontrolera z tabelą danych otrzymanych z iPhone przez 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 dla aplikacji fitness

Workout API — zestaw klas WatchKit do tworzenia aplikacji fitness, które mogą uruchamiać treningi na Apple Watch w tle. API udostępnia dostęp do czujników: akcelerometru, żyroskopu, pulsometru (przez HKHealthStore) i GPS (w modelach Watch z GPS). Treningi uruchamiane są przez HKWorkoutSession z HealthKit, a dane pulsu aktualizowane są w czasie rzeczywistym przez HKSampleQuery.

Kluczową zaletą Workout API jest możliwość pracy w tle. Gdy trening jest aktywny, watchOS nie zawiesza aplikacji przy opuszczaniu ręki — czujniki kontynuują zbieranie danych, a aplikacja może wyświetlać puls, dystans, tempo i inne metryki. Po zakończeniu treningu dane są synchronizowane z Health App na iPhone przez HealthKit, co zapewnia jednolity profil fitness użytkownika.

Uruchomienie treningu z czujnikami

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