Watch App: bu nima, Apple Watch va Wear OS uchun ishlab chiqish

Watch App nima

Watch App — taqiladigan qurilmalarda ishlash uchun mo'ljallangan ilova: Apple Watch (watchOS) va Wear OS aqlli soatlari. Mobil ilovadan asosiy farq — shakl omili. Soat ekrani diametri 1.5–2 dyuym (smartfonda 6–7 dyuymga nisbatan), bu bir vaqtda ko'rsatiladigan ma'lumot miqdorini cheklaydi. Ilova bilan o'zaro aloqa qisqa — foydalanuvchi vaqt, bildirishnoma, yurak urishi yoki qadamlarni 5–15 soniya ichida tekshiradi, so'ng qo'lini tushiradi.

Watch Appning asosiy stsenariylari: fitnes kuzatuvchisi (qadamlar, yurak urishi, kaloriyalar, uyqu), bildirishnomalar (xabarlar, qo'ng'iroqlar, taqvim), tezkor harakatlar (taymerni ishga tushirish, xabarga ovozli javob berish, musiqani boshqarish), hamroh (kamera pulti, avtomobil kalitlari, NFC to'lovlari). Counterpoint Research (2026) ma'lumotlariga ko'ra, global aqlli soat bozori yiliga 150 million qurilmani tashkil etadi, shundan Apple Watch 35%, Wear OS 20%, qolgani — Fitbit, Garmin va boshqalar.

Watch App cheklovlari: kichik ekran (2 dyuymgacha), cheklangan batareya ishlash muddati (18–24 soatgacha), to'liq klaviaturaning yo'qligi (faqat ovozli kiritish yoki diktant), fon vazifalari limiti (watchOS — 10 daqiqagacha, Wear OS — 5 daqiqagacha), ko'pchilik funksiyalar uchun telefon bilan sinxronlash zaruriyati. watchOS 6 (2019) va Wear OS 3 (2022) dan boshlab ilovalar LTE moduli orqali telefonsiz avtonom ishlashi mumkin.

Apple Watch: watchOS va SwiftUI

watchOS — Apple-ning iOS ga asoslangan va bir xil freymvorklardan (Foundation, UIKit moslashtirilgan versiyada, SwiftUI) foydalanadigan aqlli soatlar uchun operatsion tizimi. Ishlab chiqish Xcode da Swift tilida amalga oshiriladi. Asosiy UI freymvorki — SwiftUI, watchOS ga xos komponentlarni taqdim etadi: karuselli TabView, NavigationStack, DigitalCrownModifier orqali raqamli toj (Digital Crown), uzoq bosish menyusi.

watchOS navigatsiyasi iyerarxik paradigmaga asoslanadi. Asosiy elementlar: iyerarxik stack (NavigationStack avtomatik qaytish bilan), modal taqdimotlar (sheet), sahifa asosidagi navigatsiya (.tabViewStyle(.page) bilan TabView), uzoq bosishda kontekst menyulari. Digital Crown tarkibni aylantirish va qiymatlarni o'zgartirish imkonini beradi. Jestlar: teginish, uzoq bosish, surish, Force Touch (watchOS 7 gacha), Digital Crown aylantirish.

watchOS ning asosiy freymvorklari: HealthKit (salomatlik ma'lumotlariga kirish — yurak urishi, qadamlar, uyqu, EKG), CoreMotion (akselerometr, giroskop), WatchConnectivity (iPhone bilan ma'lumot almashish), ClockKit (siferblatda komplikatsiyalar), BackgroundTasks (fon yangilanishlari 10 daqiqagacha), ARKit (Series 9+ da effektlar bilan FaceTime). Watch App to'liq huquqli (dockda alohida ilova) yoki kengaytma (iOS versiyasi bilan bir vaqtda) bo'lishi mumkin.

Wear OS: Kotlin va Compose

Wear OS — Android ga asoslangan Google-ning aqlli soatlar platformasi. Zamonaviy ishlab chiqish Kotlin tilida Jetpack Compose for Wear OS bilan amalga oshiriladi — dumaloq ekranlar uchun optimallashtirilgan komponentlar to'plami: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. Mobil Compose dan farqli o'laroq, Wear OS o'z modifierlaridan foydalanadi: scrollable vertikal aylantirish uchun, swipable surish uchun, RotaryInput aylantirgichni boshqarish uchun.

Wear OS navigatsiyasi yon paneldan (SwipeToDismiss) va ekran-kartlardan foydalanadi. Asosiy elementlar: SwipeDismissableNavHost (surish bilan qaytish navigatsiyasi), ekranlarni joylashtirish (ro'yxatlar uchun ScalingLazyColumn), gorizontal karusel (Carousel), siferblat (WatchFace WatchFaceService orqali). Google qaytish uchun yon surishni va ro'yxatlar uchun vertikal aylantirishni tavsiya qiladi. Soatdagi quvvat tugmasi oxirgi ilovalar ro'yxatini ochadi.

Wear OS da salomatlik va sensorlar: Health Services API (ma'lumot yetkazib beruvchilar orqali qadamlar, yurak urishi, kaloriyalar, uyqu, SpO2), SensorManager (akselerometr, giroskop, barometr, magnitometr), Location Services (FusedLocationProvider orqali GPS). Wear OS 5+ yugurish, yurish, velosiped haydash va suzishni faoliyat turini avtomatik aniqlash bilan qo'llab-quvvatlaydi. Ma'lumotlar Health Connect orqali Google Fit bilan sinxronlanadi.

Kod namunasi: Apple Watch uchun Swift

SwiftUI va HealthKit yordamida Apple Watch da yurak urishini kuzatish ilovasini ko'rib chiqamiz.

import SwiftUI
import HealthKit

// Yurak urishi uchun ma'lumot modeli
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

// HealthKit uchun ViewModel
@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)
    }
}

// Asosiy ekran
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)
    }
}

Asosiy nuqtalar: HKHealthStore HealthKit ma'lumotlariga kirishni so'raydi; HKObserverQuery real vaqtda yurak urishi o'zgarishlari haqida xabar beradi; HKSampleQuery oxirgi qiymatni oladi. Watch App @Observable tufayli currentHeartRate o'zgarganda UI ni avtomatik yangilaydi. HealthKit ma'lumotlarni qurilmada mahalliy qayta ishlaydi — server so'rovlari talab qilinmaydi.

Kod namunasi: Wear OS uchun Kotlin

Jetpack Compose va Health Services API bilan Wear OS uchun o'xshash ilova.

// 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 — sensorlarga kirish uchun API
        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 = "Yurak urishi",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

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

Wear OS ning asosiy komponentlari: odatiy layout uchun Scaffold TimeText va Vignette bilan; .scrollable() modifier dumaloq ekran bilan moslik uchun; yurak urishi sensorlariga kirish uchun HealthService (Horologist). Jetpack Compose for Wear OS interfeysni avtomatik ravishda dumaloq va kvadrat ekranlarga moslashtiradi — dasturchi turli shakl omillarini qo'lda boshqarishi shart emas.