Watch App: यह क्या है, Apple Watch और Wear OS के लिए विकास

Watch App क्या है

Watch App एक एप्लिकेशन है जो पहनने योग्य उपकरणों पर काम करने के लिए डिज़ाइन किया गया है: Apple Watch (watchOS) और Wear OS पर स्मार्टवॉच। मोबाइल एप्लिकेशन से मुख्य अंतर फॉर्म फैक्टर है। घड़ी की स्क्रीन का विकर्ण 1.5–2 इंच है (स्मार्टफोन के 6–7 इंच की तुलना में), जो एक साथ प्रदर्शित जानकारी की मात्रा को सीमित करता है। एप्लिकेशन के साथ इंटरैक्शन छोटा है — उपयोगकर्ता 5–15 सेकंड में समय, सूचना, हृदय गति या कदम देखता है, फिर हाथ नीचे कर लेता है।

मुख्य Watch App परिदृश्य: फिटनेस ट्रैकर (कदम, हृदय गति, कैलोरी, नींद), सूचनाएं (संदेश, कॉल, कैलेंडर), त्वरित क्रियाएं (टाइमर शुरू करना, आवाज से संदेश का उत्तर देना, संगीत नियंत्रित करना), साथी (कैमरा रिमोट, कार की चाबियां, NFC भुगतान)। Counterpoint Research (2026) के अनुसार, वैश्विक स्मार्टवॉच बाजार प्रति वर्ष 150 मिलियन उपकरणों से अधिक है, जिसमें से Apple Watch का 35%, Wear OS का 20%, शेष Fitbit, Garmin और अन्य का है।

Watch App सीमाएं: छोटी स्क्रीन (2 इंच तक), सीमित बैटरी जीवन (18–24 घंटे तक), कोई पूर्ण कीबोर्ड नहीं (केवल वॉइस इनपुट या डिक्टेशन), बैकग्राउंड कार्यों की सीमा (watchOS — 10 मिनट तक, Wear OS — 5 मिनट तक), अधिकांश कार्यों के लिए फोन के साथ सिंक की आवश्यकता। watchOS 6 (2019) और Wear OS 3 (2022) से शुरू होकर, एप्लिकेशन फोन के साथ जोड़े बिना LTE मॉड्यूल के माध्यम से स्वायत्त रूप से काम कर सकते हैं।

Apple Watch: watchOS और SwiftUI

watchOS स्मार्टवॉच के लिए Apple का ऑपरेटिंग सिस्टम है, जो iOS पर आधारित है और उन्हीं फ्रेमवर्क (Foundation, UIKit अनुकूलित संस्करण में, SwiftUI) का उपयोग करता है। विकास Xcode में Swift का उपयोग करके किया जाता है। मुख्य UI फ्रेमवर्क SwiftUI है, जो watchOS-विशिष्ट घटक प्रदान करता है: कैरोसेल के साथ TabView, NavigationStack, DigitalCrownModifier के माध्यम से डिजिटल क्राउन, लॉन्ग-प्रेस मेनू।

watchOS पर नेविगेशन पदानुक्रमित प्रतिमान पर बनाया गया है। मुख्य तत्व: पदानुक्रमित स्टैक (स्वचालित वापसी के साथ NavigationStack), मोडल प्रस्तुतियां (sheet), पृष्ठ-आधारित नेविगेशन (.tabViewStyle(.page) के साथ TabView के माध्यम से), लॉन्ग प्रेस पर संदर्भ मेनू। डिजिटल क्राउन सामग्री को स्क्रॉल करने और मान बदलने की अनुमति देता है। जेस्चर: टैप, लॉन्ग प्रेस, स्वाइप, Force Touch (watchOS 7 तक), डिजिटल क्राउन रोटेशन।

मुख्य watchOS फ्रेमवर्क: HealthKit (स्वास्थ्य डेटा तक पहुंच — हृदय गति, कदम, नींद, ECG), CoreMotion (एक्सेलेरोमीटर, जाइरोस्कोप), WatchConnectivity (iPhone के साथ डेटा आदान-प्रदान), ClockKit (वॉच फेस पर कॉम्प्लिकेशन), BackgroundTasks (10 मिनट तक बैकग्राउंड अपडेट), ARKit (Series 9+ पर FaceTime प्रभाव)। Watch App पूर्ण-विशेषताओं वाला (डॉक में अलग एप्लिकेशन) या एक्सटेंशन (iOS संस्करण के साथ एक साथ) हो सकता है।

Wear OS: Kotlin और Compose

Wear OS स्मार्टवॉच के लिए Google का प्लेटफॉर्म है, जो Android पर आधारित है। आधुनिक विकास Kotlin में Jetpack Compose for Wear OS के साथ किया जाता है — गोल स्क्रीन के लिए अनुकूलित घटकों का एक सेट: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper। मोबाइल Compose के विपरीत, Wear OS अपने स्वयं के संशोधक का उपयोग करता है: लंबवत स्क्रॉल के लिए scrollable, स्वाइप करने के लिए swipable, क्राउन नियंत्रण के लिए RotaryInput।

Wear OS पर नेविगेशन साइड पैनल (SwipeToDismiss) और कार्ड स्क्रीन का उपयोग करता है। मुख्य तत्व: SwipeDismissableNavHost (स्वाइप-बैक के साथ नेविगेशन), स्क्रीन पोजिशनिंग (सूचियों के लिए ScalingLazyColumn), क्षैतिज कैरोसेल (Carousel), वॉच फेस (WatchFaceService के माध्यम से WatchFace)। Google वापस जाने के लिए साइड स्वाइप और सूचियों के लिए लंबवत स्क्रॉल का उपयोग करने की सलाह देता है। घड़ी पर पावर बटन हाल के एप्लिकेशन की सूची खोलता है।

Wear OS पर स्वास्थ्य और सेंसर: Health Services API (डेटा प्रदाताओं के माध्यम से कदम, हृदय गति, कैलोरी, नींद, SpO2), SensorManager (एक्सेलेरोमीटर, जाइरोस्कोप, बैरोमीटर, मैग्नेटोमीटर), Location Services (FusedLocationProvider के माध्यम से GPS)। Wear OS 5+ गतिविधि प्रकार का स्वचालित पता लगाने के साथ दौड़ने, चलने, साइकिल चलाने और तैराकी को ट्रैक करने का समर्थन करता है। डेटा Health Connect के माध्यम से Google Fit के साथ सिंक होता है।

कोड उदाहरण: Apple Watch के लिए Swift

SwiftUI और HealthKit का उपयोग करके Apple Watch के लिए हृदय गति ट्रैकिंग एप्लिकेशन देखें।

import SwiftUI
import HealthKit

// हृदय गति डेटा मॉडल
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

// HealthKit के लिए 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)
    }
}

// मुख्य स्क्रीन
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)
    }
}

मुख्य बिंदु: HKHealthStore HealthKit डेटा तक पहुंच का अनुरोध करता है; HKObserverQuery वास्तविक समय में हृदय गति परिवर्तनों के बारे में सूचित करता है; HKSampleQuery नवीनतम मान प्राप्त करता है। @Observable के कारण currentHeartRate बदलने पर Watch App स्वचालित रूप से UI अपडेट करता है। HealthKit डेटा को डिवाइस पर स्थानीय रूप से संसाधित करता है — सर्वर अनुरोधों की आवश्यकता नहीं है।

कोड उदाहरण: Wear OS के लिए Kotlin

Jetpack Compose और Health Services API के साथ Kotlin में Wear OS के लिए समान एप्लिकेशन।

// 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
        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 = "हृदय गति",
                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 के मुख्य घटक: मानक लेआउट के लिए TimeText और Vignette के साथ Scaffold; गोल स्क्रीन संगतता के लिए .scrollable() संशोधक; हृदय गति सेंसर पहुंच के लिए HealthService (Horologist)। Jetpack Compose for Wear OS स्वचालित रूप से गोल और चौकोर स्क्रीन के लिए इंटरफ़ेस को अनुकूलित करता है — डेवलपर को विभिन्न फॉर्म फैक्टर को मैन्युअल रूप से संभालने की आवश्यकता नहीं है।