Watch App: ce este, dezvoltare pentru Apple Watch și Wear OS

Ce este Watch App

Watch App — este o aplicație concepută pentru a funcționa pe dispozitive purtabile: Apple Watch (watchOS) și ceasuri inteligente pe Wear OS. Diferența principală față de aplicația mobilă — factorul de formă. Ecranul ceasului are diagonala de 1.5–2 inci (față de 6–7 inci la smartphone), ceea ce limitează cantitatea de informații afișate simultan. Interacțiunea cu aplicația este scurtă — utilizatorul verifică ora, notificarea, pulsul sau pașii în 5–15 secunde, după care coboară mâna.

Scenarii cheie Watch App: tracker fitness (pași, puls, calorii, somn), notificări (mesaje, apeluri, calendar), acțiuni rapide (pornire cronometru, răspuns vocal la mesaj, control muzică), companion (telecomandă pentru cameră, chei mașină, plată NFC). Potrivit Counterpoint Research (2026), piața globală a ceasurilor inteligente depășește 150 de milioane de dispozitive pe an, din care Apple Watch ocupă 35%, Wear OS — 20%, restul — Fitbit, Garmin și altele.

Limitări Watch App: ecran mic (până la 2 inci), durată limitată de funcționare a bateriei (până la 18–24 ore), lipsa tastaturii complete (doar introducere vocală sau dictare), limită pentru sarcinile de fundal (watchOS — până la 10 minute, Wear OS — până la 5 minute), necesitatea sincronizării cu telefonul pentru majoritatea funcțiilor. Începând cu watchOS 6 (2019) și Wear OS 3 (2022) aplicațiile pot funcționa autonom prin modulul LTE fără asociere cu telefonul.

Apple Watch: watchOS și SwiftUI

watchOS — sistemul de operare Apple pentru ceasuri inteligente, bazat pe iOS și care utilizează aceleași framework-uri (Foundation, UIKit în versiune adaptată, SwiftUI). Dezvoltarea se face în Xcode în Swift. Principalul framework UI — SwiftUI, care oferă componente specifice watchOS: TabView cu carusel, NavigationStack, coroana digitală (Digital Crown) prin DigitalCrownModifier, meniu de apăsare lungă.

Navigarea pe watchOS se bazează pe paradigma ierarhică. Elemente principale: stivă ierarhică (NavigationStack cu revenire automată), prezentări modale (sheet), navigare pe pagini (page-based prin TabView cu .tabViewStyle(.page)), meniuri context la apăsare lungă. Digital Crown permite derularea conținutului și modificarea valorilor. Gesturi: atingere, apăsare lungă, glisare, Force Touch (până la watchOS 7), rotire Digital Crown.

Framework-uri cheie watchOS: HealthKit (acces la datele de sănătate — puls, pași, somn, EKG), CoreMotion (accelerometru, giroscop), WatchConnectivity (schimb de date cu iPhone), ClockKit (complicații pe cadran), BackgroundTasks (actualizări de fundal până la 10 minute), ARKit (FaceTime cu efecte pe Series 9+). Watch App poate fi complet (aplicație separată în dock) sau extensie (simultan cu versiunea iOS).

Wear OS: Kotlin și Compose

Wear OS — platforma Google pentru ceasuri inteligente, bazată pe Android. Dezvoltarea modernă se face în Kotlin cu Jetpack Compose for Wear OS — un set de componente optimizate pentru ecrane rotunde: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. Spre deosebire de Compose mobil, Wear OS folosește proprii modificatori: scrollable pentru derulare verticală, swipable pentru glisare, RotaryInput pentru controlul coroanei.

Navigarea pe Wear OS folosește panoul lateral (SwipeToDismiss) și ecrane-carte. Elemente principale: SwipeDismissableNavHost (navigare cu revenire prin glisare), poziționarea ecranelor (ScalingLazyColumn pentru liste), carusel orizontal (Carousel), cadran (WatchFace prin WatchFaceService). Google recomandă utilizarea glisării laterale pentru revenire și derularea verticală pentru liste. Butonul de alimentare de pe ceas deschide lista aplicațiilor recente.

Sănătate și senzori pe Wear OS: Health Services API (pași, puls, calorii, somn, SpO2 prin furnizori de date), SensorManager (accelerometru, giroscop, barometru, magnetometru), Location Services (GPS prin FusedLocationProvider). Wear OS 5+ suportă urmărirea alergării, mersului, ciclismului și înotului cu detectare automată a tipului de activitate. Datele se sincronizează cu Google Fit prin Health Connect.

Exemplu cod: Swift pentru Apple Watch

Să examinăm o aplicație de urmărire a pulsului pe Apple Watch folosind SwiftUI și HealthKit.

import SwiftUI
import HealthKit

// Model de date pentru puls
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

// ViewModel pentru 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)
    }
}

// Ecran principal
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)
    }
}

Puncte cheie: HKHealthStore solicită acces la datele HealthKit; HKObserverQuery notifică despre modificările pulsului în timp real; HKSampleQuery obține ultima valoare. Watch App actualizează automat UI la modificarea currentHeartRate datorită @Observable. HealthKit procesează datele local pe dispozitiv — nu sunt necesare cereri către server.

Exemplu cod: Kotlin pentru Wear OS

Aplicație similară pentru Wear OS în Kotlin cu Jetpack Compose și Health Services API.

// MainActivity.kt
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.wear.compose.material.*
import androidx.wear.compose.foundation.arc.BasicArcParams
import com.google.android.horologist.health.HealthService

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            WearAppTheme {
                HeartRateScreen()
            }
        }
    }
}

@Composable
fun HeartRateScreen() {
    var heartRate by remember { mutableIntStateOf(0) }
    var isConnected by remember { mutableStateOf(false) }

    LaunchedEffect(Unit) {
        // HealthService — API pentru acces la senzori
        val healthService = HealthService()
        healthService.connect().onSuccess {
            isConnected = true
        }
    }

    Scaffold(
        timeText = { TimeText() },
        vignette = { Vignette(vignettePosition = VignettePosition.TopAndBottom) }
    ) {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .scrollable(state = ScrollState),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {
            Icon(
                imageVector = Icons.Filled.Favorite,
                contentDescription = "Puls",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

            Text(
                text = heartRate.toString(),
                style = MaterialTheme.typography.display1
            )
            Text(
                text = "BPM",
                style = MaterialTheme.typography.caption2
            )
        }
    }
}

Componente cheie Wear OS: Scaffold cu TimeText și Vignette pentru layout tipic; modificatorul .scrollable() pentru compatibilitate cu ecranul rotund; HealthService (Horologist) pentru acces la senzorii de puls. Jetpack Compose for Wear OS adaptează automat interfața pentru ecrane rotunde și pătrate — dezvoltatorul nu trebuie să gestioneze manual diferiți factori de formă.