Watch App: ano ito, pag-develop para sa Apple Watch at Wear OS

Ano ang Watch App

Watch App — ay isang aplikasyon na dinisenyo para gumana sa naisusuot na aparato: Apple Watch (watchOS) at smartwatch na Wear OS. Ang pangunahing pagkakaiba sa mobile app — ang factor ng anyo. Ang screen ng relo ay may diagonal na 1.5–2 pulgada (kumpara sa 6–7 pulgada ng smartphone), na naglilimita sa dami ng impormasyong ipinapakita nang sabay. Ang interaksyon sa app ay maikli — sinusuri ng gumagamit ang oras, notipikasyon, pulso, o hakbang sa loob ng 5–15 segundo, pagkatapos ay ibinababa ang kamay.

Mga pangunahing senaryo ng Watch App: fitness tracker (hakbang, pulso, calorie, tulog), notipikasyon (mensahe, tawag, kalendaryo), mabilisang aksyon (pagsimula ng timer, pagsagot sa mensahe gamit ang boses, pagkontrol ng musika), kasama (remote para sa camera, susi ng kotse, NFC payment). Ayon sa Counterpoint Research (2026), ang pandaigdigang merkado ng smartwatch ay lumalampas sa 150 milyong aparato bawat taon, kung saan ang Apple Watch ay may 35%, Wear OS — 20%, ang natitira — Fitbit, Garmin at iba pa.

Mga limitasyon ng Watch App: maliit na screen (hanggang 2 pulgada), limitadong buhay ng baterya (hanggang 18–24 oras), kawalan ng kumpletong keyboard (voice input lamang o dikta), limitasyon sa mga gawain sa background (watchOS — hanggang 10 minuto, Wear OS — hanggang 5 minuto), pangangailangan ng sync sa telepono para sa karamihan ng mga function. Mula watchOS 6 (2019) at Wear OS 3 (2022) ang mga app ay maaaring gumana nang awtonomo sa pamamagitan ng LTE module nang walang pairing sa telepono.

Apple Watch: watchOS at SwiftUI

watchOS — operating system ng Apple para sa smartwatch, batay sa iOS at gumagamit ng parehong framework (Foundation, UIKit sa inangkop na bersyon, SwiftUI). Ang pag-develop ay ginagawa sa Xcode gamit ang Swift. Ang pangunahing UI framework — SwiftUI, na nagbibigay ng mga bahaging espesipiko sa watchOS: TabView na may carousel, NavigationStack, digital crown (Digital Crown) sa pamamagitan ng DigitalCrownModifier, menu ng mahabang pagpindot.

Nabigasyon sa watchOS ay batay sa hirarkikong paradigma. Mga pangunahing elemento: hirarkikong stack (NavigationStack na may awtomatikong pagbabalik), modal presentation (sheet), page-based na nabigasyon (sa pamamagitan ng TabView na may .tabViewStyle(.page)), context menu sa mahabang pagpindot. Pinapayagan ng Digital Crown ang pag-scroll ng nilalaman at pagbabago ng mga halaga. Mga kilos: tap, mahabang pagpindot, swipe, Force Touch (hanggang watchOS 7), pag-ikot ng Digital Crown.

Mga pangunahing framework ng watchOS: HealthKit (access sa data ng kalusugan — pulso, hakbang, tulog, EKG), CoreMotion (accelerometer, gyroscope), WatchConnectivity (pagpapalitan ng data sa iPhone), ClockKit (complication sa mukha ng relo), BackgroundTasks (background update hanggang 10 minuto), ARKit (FaceTime na may epekto sa Series 9+). Ang Watch App ay maaaring buong app (hiwalay na app sa dock) o extension (kasabay ng iOS na bersyon).

Wear OS: Kotlin at Compose

Wear OS — platform ng Google para sa smartwatch, batay sa Android. Ang modernong pag-develop ay ginagawa sa Kotlin na may Jetpack Compose for Wear OS — isang set ng mga bahaging na-optimize para sa bilog na screen: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. Hindi tulad ng mobile Compose, ang Wear OS ay gumagamit ng sarili nitong modifier: scrollable para sa vertical na pag-scroll, swipable para sa pag-swipe, RotaryInput para sa pagkontrol ng knob.

Nabigasyon sa Wear OS ay gumagamit ng side panel (SwipeToDismiss) at screen-card. Mga pangunahing elemento: SwipeDismissableNavHost (nabigasyon na may pagbabalik sa pamamagitan ng pag-swipe), pagpoposisyon ng screen (ScalingLazyColumn para sa listahan), horizontal carousel (Carousel), mukha ng relo (WatchFace sa pamamagitan ng WatchFaceService). Inirerekomenda ng Google ang paggamit ng side swipe para sa pagbabalik at vertical scroll para sa listahan. Ang power button sa relo ay nagbubukas ng listahan ng mga kamakailang app.

Kalusugan at sensor sa Wear OS: Health Services API (hakbang, pulso, calorie, tulog, SpO2 sa pamamagitan ng data provider), SensorManager (accelerometer, gyroscope, barometer, magnetometer), Location Services (GPS sa pamamagitan ng FusedLocationProvider). Ang Wear OS 5+ ay sumusuporta sa pagsubaybay ng pagtakbo, paglalakad, pagbibisikleta at paglangoy na may awtomatikong pagtukoy ng uri ng aktibidad. Ang data ay nasi-sync sa Google Fit sa pamamagitan ng Health Connect.

Halimbawa ng code: Swift para sa Apple Watch

Tingnan natin ang isang app para sa pagsubaybay ng pulso sa Apple Watch gamit ang SwiftUI at HealthKit.

import SwiftUI
import HealthKit

// Modelo ng data para sa pulso
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

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

// Pangunahing screen
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)
    }
}

Mga pangunahing punto: HKHealthStore ay humihiling ng access sa data ng HealthKit; HKObserverQuery ay nag-aabiso tungkol sa mga pagbabago sa pulso sa real-time; HKSampleQuery ay kumukuha ng huling halaga. Awtomatikong ina-update ng Watch App ang UI kapag nagbago ang currentHeartRate dahil sa @Observable. Pinoproseso ng HealthKit ang data nang lokal sa aparato — hindi kailangan ang mga request sa server.

Halimbawa ng code: Kotlin para sa Wear OS

Ang katulad na app para sa Wear OS sa Kotlin na may Jetpack Compose at 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 para sa access sa sensor
        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 = "Pulso",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

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

Mga pangunahing bahagi ng Wear OS: Scaffold na may TimeText at Vignette para sa tipikal na layout; .scrollable() modifier para sa compatibility sa bilog na screen; HealthService (Horologist) para sa access sa pulse sensor. Ang Jetpack Compose for Wear OS ay awtomatikong nag-a-adjust ng interface para sa bilog at parisukat na screen — hindi kailangan ng developer na manual na pangasiwaan ang iba't ibang factor ng anyo.