watchOS: elementele de bază ale dezvoltării pentru Apple Watch cu SwiftUI

Ce este watchOS?

watchOS — sistemul de operare pentru ceasurile inteligente Apple, bazat pe nucleul XNU Darwin. Lansat pentru prima dată pe 24 aprilie 2015 împreună cu Apple Watch Series 0. Sistemul este construit pe aceeași arhitectură ca iOS, dar optimizat pentru ecranul mic (1,5 până la 1,9 inci), memoria limitată (până la 1 GB RAM în Series 9) și consumul minim de energie.

Potrivit StatCounter (2026), watchOS deține aproximativ 55% din piața sistemelor de operare pentru ceasuri inteligente, depășind Wear OS și sistemele proprietare ale producătorilor chinezi. Apple lansează anual actualizări majore watchOS, suportând ceasurile până la 5 ani de la lansare.

Caracteristica cheie a watchOS — dependența de iPhone. Majoritatea aplicațiilor folosesc Watch Connectivity pentru sincronizarea datelor. Începând cu watchOS 6, ceasurile pot instala aplicații direct din App Store, dar autonomia completă fără iPhone este suportată doar din watchOS 9.

Istoria versiunilor watchOS

Prima versiune Watch OS 1.0 nu suporta aplicații terțe — doar aplicațiile preinstalate Apple. watchOS 2 (2015) a deschis SDK-ul pentru dezvoltatori. watchOS 3 (2016) a accelerat lansarea aplicațiilor de 7 ori. watchOS 6 (2019) a introdus App Store pe ceas. watchOS 9 (2022) a adăugat medicamente și urmărirea îmbunătățită a somnului. watchOS 10 (2023) a devenit cea mai mare actualizare a interfeței de la lansare.

Arhitectura watchOS

Arhitectura watchOS constă din trei niveluri care izolează hardware-ul de aplicațiile utilizatorului. Spre deosebire de iOS, watchOS folosește o abordare componentă: aplicația constă din două target-uri — extensia (extension) și gazda pe iPhone.

Nucleul și serviciile de sistem

Nivelul inferior — nucleul XNU modificat cu drivere pentru cipurile S4/S5/S6/S7/S8/S9 Apple. În Apple Watch Series 9 se folosește S9 SiP cu 5,6 miliarde de tranzistori și Neural Engine cu 4 nuclee. Serviciile de sistem includ Core Bluetooth, Watch Connectivity, HealthKit și Core Motion. Toate sarcinile de fundal sunt gestionate de BGTaskScheduler — planificatorul de sistem care optimizează consumul de energie.

WatchKit — nivelul aplicațiilor

WatchKit — framework pentru crearea interfețelor aplicațiilor watchOS. Include WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel și WKInterfaceButton. Din watchOS 6, Apple recomandă SwiftUI în loc de WatchKit. SwiftUI oferă aceleași capacități, dar cu sintaxă declarativă și adaptare automată la dimensiunea ecranului: 38 mm (272×340), 42 mm (312×390), 40 mm (324×394), 44 mm (368×448), 45 mm (396×484), 49 mm (410×502 în Apple Watch Ultra).

Modurile de fundal și consumul de energie

watchOS limitează activitatea de fundal a aplicațiilor pentru a economisi bateria. Modurile de fundal disponibile: Workout (antrenamente), HealthKit (monitorizare sănătate), Location (geolocație), Audio (player audio) și Complication (date pe fața ceasului). Fiecare mod solicită o capability separată în entitlements. Consumul tipic de energie: aplicație activă — 50-80 mA, mod fundal — 5-15 mA, Standby — 1-3 mA.

import BackgroundTasks
import WatchKit

/// Planificarea actualizării datelor în fundal pe 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)
            }
        }
    }
}

/// Înregistrarea sarcinii de fundal în 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 garantează că sarcinile de fundal sunt executate în momente optime — când ceasul este la încărcător și conectat la iPhone. WKExtensionDelegate procesează sarcinile de fundal primite și actualizează datele de pe fața ceasului. ComplicationController.reloadComplications actualizează widget-urile pe fața ceasului selectată.

watchOS 10: Smart Stack și Double Tap

watchOS 10 — cea mai mare actualizare a interfeței din istoria platformei, lansată în septembrie 2023. Sistemul a trecut de la navigarea ierarhică la navigarea orientată pe conținut: ecranul principal a devenit Smart Stack — stiva inteligentă de widget-uri care a înlocuit dock-ul aplicațiilor.

Smart Stack

Smart Stack — lista verticală de widget-uri afișată sub fața ceasului. Widget-urile sunt clasificate în funcție de context: dimineața se afișează vremea și calendarul, ziua — activitatea și mementourile, seara — meditația și pregătirea pentru somn. Dezvoltatorul poate adăuga widget-uri personalizate prin WidgetKit pentru watchOS, folosind aceleași API-uri ca pentru iOS 17.

Double Tap

Double Tap — gestul de a uni degetul arătător cu degetul mare, recunoscut de accelerometru și giroscop fără a atinge ecranul. În Apple Watch Series 9 și Ultra 2, gestul este executat la nivel hardware prin Neural Engine. Dezvoltatorul primește evenimentul prin UIDoubleTapGestureRecognizer sau prin modificatorul SwiftUI .onTapGesture(count: 2). Gestul nu necesită calibrare și funcționează în orice orientare a mâinii.

Noi API-uri pentru dezvoltatori

watchOS 10 a introdus: SwiftUI Animation cu suport pentru animații Spring și Keyframe, MapKit pentru afișarea hărților pe ceas, VideoPlayer pentru redarea videoclipurilor scurte (până la 30 de secunde), VoiceOver îmbunătățit cu gesturi și noua paradigmă de navigare NavigationStack în loc de NavigationView.

SwiftUI pentru Apple Watch

SwiftUI — framework-ul principal pentru dezvoltarea interfețelor pe watchOS. Apple recomandă SwiftUI pentru toate proiectele noi începând cu watchOS 7. SwiftUI pentru ceasuri folosește aceleași principii ca pentru iOS, dar cu modificatori și componente specifice watchOS.

Componente SwiftUI specifice watchOS

SwiftUI pentru watchOS include: TabView cu stil page pentru glisarea între ecrane, DigitalCrownRotation pentru procesarea rotirii coroanei, SceneStorage pentru salvarea stării între porniri, WKNotificationScene pentru notificări personalizate și ComplicationDescriptor pentru datele pe fața ceasului.

import SwiftUI
import HealthKit

/// Aplicație watchOS pentru monitorizarea pulsului
@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("Pași", systemImage: "figure.walk") }

            SettingsView()
                .tabItem { Label("Setări", 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)
        }
    }
}

Aplicația HeartMonitorApp demonstrează structura tipică a unei aplicații watchOS în SwiftUI: TabView cu stil page pentru glisarea între ecrane, integrare cu HealthKit pentru citirea pulsului în timp real, WKNotificationScene pentru procesarea notificărilor. SymbolEffect cu animație pulse utilizează accelerarea hardware a Neural Engine pentru animație lină fără a încărca CPU.

Digital Crown și gesturi

Digital Crown — coroana de pe panoul lateral al Apple Watch. SwiftUI oferă DigitalCrownRotation pentru a lega o valoare de rotirea coroanei. Modificatorul primește un binding, un interval și un pas. Gesturi: tap (atingere), longPress (apăsare lungă), swipe (glisare) și pan (tragere) — toate standard pentru SwiftUI și adaptate la dimensiunea ecranului ceasului.

WatchKit și componentele aplicației watchOS

WatchKit — framework-ul original pentru watchOS, care folosește abordarea UIKit. Deși Apple recomandă SwiftUI, WatchKit rămâne relevant pentru proiecte vechi și sarcini specifice: animații complexe pe WKInterfaceGroup și integrarea cu SiriKit.

Structura aplicației watchOS

Aplicația pentru watchOS constă din două target-uri: WatchKit Extension (logică și interfață) și iOS Companion App (setări și sincronizare). Începând cu Xcode 15, este posibilă crearea unei aplicații standalone fără companion iOS. Interfața este descrisă în Interface.storyboard (WatchKit) sau programatic prin SwiftUI.

Complications — date pe fața ceasului

Complication — widget care afișează date pe fața Apple Watch. Dezvoltatorul implementează protocolul CLKComplicationDataSource, furnizând șabloane pentru diferite tipuri de fețe de ceas (circular, rectangular, modular, extraLarge). watchOS 10 suportă ComplicationDescriptor — API simplificat pentru SwiftUI. Datele sunt actualizate prin Background Tasks cu o perioadă de până la 30 de minute.

Integrarea cu iPhone prin Watch Connectivity

Watch Connectivity — framework pentru schimbul de date între Apple Watch și iPhone prin Bluetooth sau Wi-Fi. Singurul mod de comunicare între dispozitivele asociate. WCSession — clasa centrală care gestionează sesiunea. Aplicația iOS și extensia watchOS trebuie să implementeze WCSessionDelegate.

Metode de transmitere a datelor

Watch Connectivity oferă patru metode de transmitere a datelor: sendMessage — trimitere imediată cu confirmare (funcționează doar când ambele aplicații sunt active), transferUserInfo — livrare în fundal a unui dicționar de date, transferFile — transmitere fișiere cu metadate, updateApplicationContext — sincronizare a stării comune. Toate metodele garantează livrarea la restabilirea conexiunii.

import WatchConnectivity

/// Manager de sincronizare între iPhone și 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: — Trimiterea datelor de pe iPhone pe ceas
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // Dacă ceasul este indisponibil — salvăm în context
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("Send error: \(error.localizedDescription)")
        }
    }

    // MARK: — Primirea datelor pe ceas
    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)")
    }

    // Nu este necesar pe watchOS, dar obligatoriu pentru protocol
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

ConnectivityManager implementează un singleton pentru lucrul cu WCSession. sendWorkoutData verifică isReachable: dacă ceasul este activ, datele sunt trimise imediat prin sendMessage; dacă nu — sunt salvate în applicationContext pentru livrare întârziată. onReceiveMessage pe partea primitoare procesează mesajele primite și notifică aplicația prin NotificationCenter.

Schimb de fișiere și sincronizare

transferFile permite transmiterea unor volume mari de date: imagini, fișiere audio, arhive. Dimensiunea maximă a fișierului — 100 MB. Fișierele sunt salvate în directorul Inbox pe dispozitivul primitor. transferUserInfo este potrivit pentru date JSON de până la 100 KB. Toate metodele funcționează în fundal: dacă dispozitivul este indisponibil, transmisia este pusă în coadă și reluată automat la restabilirea conexiunii.

Publicarea aplicațiilor watchOS

Publicarea aplicației watchOS respectă aceleași reguli ca iOS: este necesară o subscripție Apple Developer Program (99 USD/an) și trecerea moderării App Review. Aplicația este încărcată în App Store Connect ca parte a aplicației iOS sau ca aplicație standalone.

Construire și distribuție

Aplicația watchOS poate fi livrată în două moduri: ca extensie încorporată a aplicației iOS (iOS app bundle conține watchOS .app) sau ca aplicație standalone (se descarcă și funcționează fără iPhone). Pentru modul standalone este necesar WKRunsIndependently = YES în Info.plist. Dimensiunea aplicației watchOS este limitată la 50 MB pentru descărcarea prin rețeaua celulară.

Cerințele App Review

Cerințe speciale pentru watchOS: aplicația trebuie să funcționeze corect fără un iPhone activ (dacă este declarată ca standalone), interfața trebuie să fie lizibilă fără mărire, toate elementele interactive — cel puțin 44 de puncte în dimensiune. Sunt interzise aplicațiile care dublează funcționalitatea celor încorporate (de exemplu, un pulsometru fără valoare adăugată).