watchOS: SwiftUI के साथ Apple Watch डेवलपमेंट की मूल बातें

watchOS क्या है?

watchOS Apple की स्मार्टवॉच के लिए ऑपरेटिंग सिस्टम है, जो Darwin XNU कर्नेल पर आधारित है। पहली बार 24 अप्रैल 2015 को Apple Watch Series 0 के साथ जारी किया गया। सिस्टम उसी आर्किटेक्चर पर बनाया गया है जो iOS का है, लेकिन छोटे डिस्प्ले (1.5 से 1.9 इंच), सीमित मेमोरी (Series 9 में 1 GB RAM तक) और न्यूनतम बिजली खपत के लिए अनुकूलित है।

StatCounter (2026) के अनुसार, watchOS के पास स्मार्टवॉच ऑपरेटिंग सिस्टम बाजार का लगभग 55% हिस्सा है, जो Wear OS और चीनी निर्माताओं के मालिकाना सिस्टम से आगे है। Apple प्रतिवर्ष watchOS के प्रमुख अपडेट जारी करता है, लॉन्च के बाद 5 साल तक घड़ियों को समर्थन प्रदान करता है।

watchOS की एक प्रमुख विशेषता iPhone पर इसकी निर्भरता है। अधिकांश ऐप डेटा सिंक्रोनाइज़ेशन के लिए Watch Connectivity का उपयोग करते हैं। watchOS 6 से शुरू होकर, घड़ियाँ सीधे App Store से ऐप इंस्टॉल कर सकती हैं, लेकिन iPhone से पूर्ण स्वतंत्रता केवल watchOS 9 के साथ समर्थित है।

watchOS संस्करण इतिहास

पहला संस्करण Watch OS 1.0 तृतीय-पक्ष ऐप का समर्थन नहीं करता था — केवल पूर्व-स्थापित Apple ऐप। watchOS 2 (2015) ने डेवलपर्स के लिए SDK खोल दिया। watchOS 3 (2016) ने ऐप लॉन्च को 7 गुना तेज कर दिया। watchOS 6 (2019) ने घड़ी पर App Store पेश किया। watchOS 9 (2022) ने दवाएँ और बेहतर नींद ट्रैकिंग जोड़ी। watchOS 10 (2023) लॉन्च के बाद से सबसे बड़ा इंटरफ़ेस अपडेट बन गया।

watchOS आर्किटेक्चर

watchOS आर्किटेक्चर तीन परतों से बना है, जो हार्डवेयर को उपयोगकर्ता ऐप से अलग करता है। iOS के विपरीत, watchOS एक घटक-आधारित दृष्टिकोण का उपयोग करता है: एक ऐप दो लक्ष्यों से बना होता है — एक एक्सटेंशन और एक iPhone होस्ट।

कर्नेल और सिस्टम सेवाएँ

निचली परत Apple के S4/S5/S6/S7/S8/S9 चिप्स के लिए ड्राइवरों के साथ एक संशोधित XNU कर्नेल है। Apple Watch Series 9 5.6 बिलियन ट्रांजिस्टर और 4-कोर Neural Engine के साथ S9 SiP का उपयोग करता है। सिस्टम सेवाओं में Core Bluetooth, Watch Connectivity, HealthKit और Core Motion शामिल हैं। सभी बैकग्राउंड कार्य BGTaskScheduler — एक सिस्टम शेड्यूलर के माध्यम से प्रबंधित किए जाते हैं जो बिजली खपत को अनुकूलित करता है।

WatchKit — एप्लिकेशन परत

WatchKit watchOS ऐप इंटरफ़ेस बनाने के लिए एक फ्रेमवर्क है। इसमें WKInterfaceController, WKInterfaceGroup, WKInterfaceLabel और WKInterfaceButton शामिल हैं। watchOS 6 से, Apple WatchKit के बजाय SwiftUI की सिफारिश करता है। SwiftUI समान क्षमताएँ प्रदान करता है लेकिन घोषणात्मक सिंटैक्स और स्क्रीन आकार के लिए स्वचालित अनुकूलन के साथ: 38 मिमी (272×340), 42 मिमी (312×390), 40 मिमी (324×394), 44 मिमी (368×448), 45 मिमी (396×484), 49 मिमी (Apple Watch Ultra पर 410×502)।

बैकग्राउंड मोड और बिजली खपत

watchOS बैटरी बचाने के लिए ऐप की बैकग्राउंड गतिविधि को सीमित करता है। उपलब्ध बैकग्राउंड मोड: Workout (कसरत), HealthKit (स्वास्थ्य निगरानी), Location (जियोलोकेशन), Audio (ऑडियो प्लेयर), और Complication (वॉच फ़ेस पर डेटा)। प्रत्येक मोड को entitlements में एक अलग capability की आवश्यकता होती है। सामान्य बिजली खपत: सक्रिय ऐप — 50-80 mA, बैकग्राउंड मोड — 5-15 mA, स्टैंडबाय — 1-3 mA।

import BackgroundTasks
import WatchKit

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

/// 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 सुनिश्चित करता है कि बैकग्राउंड कार्य इष्टतम समय पर चलें — जब घड़ी चार्ज हो रही हो और iPhone से कनेक्टेड हो। WKExtensionDelegate आने वाले बैकग्राउंड कार्यों को संभालता है और वॉच फ़ेस पर डेटा अपडेट करता है। ComplicationController.reloadComplications चयनित वॉच फ़ेस पर विजेट अपडेट करता है।

watchOS 10: Smart Stack और Double Tap

watchOS 10 — प्लेटफ़ॉर्म के इतिहास में सबसे बड़ा इंटरफ़ेस अपडेट, सितंबर 2023 में जारी हुआ। सिस्टम पदानुक्रमित नेविगेशन से सामग्री-उन्मुख नेविगेशन में स्थानांतरित हो गया: मुख्य स्क्रीन Smart Stack बन गई — एक बुद्धिमान विजेट स्टैक जिसने ऐप डॉक को बदल दिया।

Smart Stack

Smart Stack वॉच फ़ेस के नीचे प्रदर्शित विजेट की एक लंबवत सूची है। विजेट संदर्भ के अनुसार क्रमबद्ध होते हैं: सुबह मौसम और कैलेंडर दिखाता है, दिन में — गतिविधि और अनुस्मारक, शाम को — ध्यान और नींद की तैयारी। डेवलपर iOS 17 के समान API का उपयोग करके WidgetKit के माध्यम से कस्टम विजेट जोड़ सकता है।

Double Tap

Double Tap तर्जनी और अंगूठे को एक साथ लाने का एक इशारा है, जिसे स्क्रीन को छुए बिना एक्सेलेरोमीटर और जाइरोस्कोप द्वारा पहचाना जाता है। Apple Watch Series 9 और Ultra 2 पर, इशारा Neural Engine के माध्यम से हार्डवेयर स्तर पर संभाला जाता है। डेवलपर UIDoubleTapGestureRecognizer या SwiftUI मॉडिफ़ायर .onTapGesture(count: 2) के माध्यम से इवेंट प्राप्त करता है। इशारे को कैलिब्रेशन की आवश्यकता नहीं है और यह किसी भी हाथ की स्थिति में काम करता है।

डेवलपर्स के लिए नए API

watchOS 10 ने पेश किए: Spring और Keyframe एनिमेशन समर्थन के साथ SwiftUI Animation, घड़ी पर मानचित्र प्रदर्शित करने के लिए MapKit, छोटे वीडियो (30 सेकंड तक) चलाने के लिए VideoPlayer, इशारों के साथ बेहतर VoiceOver, और NavigationView के बजाय नया नेविगेशन प्रतिमान NavigationStack।

Apple Watch के लिए SwiftUI

SwiftUI watchOS इंटरफ़ेस विकसित करने के लिए प्राथमिक फ्रेमवर्क है। Apple watchOS 7 से शुरू होने वाली सभी नई परियोजनाओं के लिए SwiftUI की सिफारिश करता है। घड़ी के लिए SwiftUI उन्हीं सिद्धांतों का उपयोग करता है जो iOS के लिए हैं, लेकिन watchOS-विशिष्ट मॉडिफ़ायर और घटकों के साथ।

watchOS-विशिष्ट SwiftUI घटक

watchOS के लिए SwiftUI में शामिल हैं: स्क्रीन के बीच स्वाइप करने के लिए पेज शैली के साथ TabView, क्राउन रोटेशन को संभालने के लिए DigitalCrownRotation, लॉन्च के बीच स्थिति संरक्षित करने के लिए SceneStorage, कस्टम सूचनाओं के लिए WKNotificationScene, और वॉच फ़ेस पर डेटा के लिए ComplicationDescriptor।

import SwiftUI
import HealthKit

/// हृदय गति निगरानी के लिए watchOS ऐप
@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("हृदय गति", systemImage: "heart.fill") }

            StepsView()
                .tabItem { Label("कदम", systemImage: "figure.walk") }

            SettingsView()
                .tabItem { Label("सेटिंग्स", 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("बीपीएम")
                .font(.caption)
                .foregroundStyle(.secondary)
        }
    }
}

HeartMonitorApp SwiftUI में एक विशिष्ट watchOS ऐप संरचना प्रदर्शित करता है: स्क्रीन के बीच स्वाइप करने के लिए पेज शैली के साथ TabView, रीयल-टाइम हृदय गति पढ़ने के लिए HealthKit एकीकरण, सूचनाओं को संभालने के लिए WKNotificationScene। पल्स एनिमेशन के साथ SymbolEffect CPU खपत के बिना स्मूथ एनिमेशन के लिए Neural Engine हार्डवेयर त्वरण का उपयोग करता है।

Digital Crown और इशारे

Digital Crown Apple Watch के किनारे पर लगा पहिया है। SwiftUI क्राउन रोटेशन के लिए मान बाँधने के लिए DigitalCrownRotation प्रदान करता है। मॉडिफ़ायर एक binding, रेंज और स्टेप स्वीकार करता है। इशारे: tap (स्पर्श), longPress (लंबा दबाव), swipe (स्वाइप), और pan (ड्रैग) — सभी SwiftUI के लिए मानक और घड़ी स्क्रीन आकार के अनुकूलित।

WatchKit और watchOS ऐप घटक

WatchKit मूल watchOS फ्रेमवर्क है जो UIKit दृष्टिकोण का उपयोग करता है। हालाँकि Apple SwiftUI की सिफारिश करता है, WatchKit विरासत परियोजनाओं और विशिष्ट कार्यों के लिए प्रासंगिक बना हुआ है: WKInterfaceGroup पर जटिल एनिमेशन और SiriKit एकीकरण।

watchOS ऐप संरचना

एक watchOS ऐप दो लक्ष्यों से बना होता है: WatchKit Extension (तर्क और इंटरफ़ेस) और iOS Companion App (सेटिंग्स और सिंक्रोनाइज़ेशन)। Xcode 15 से शुरू होकर, iOS साथी के बिना एक स्टैंडअलोन ऐप बनाना संभव है। इंटरफ़ेस Interface.storyboard (WatchKit) में या SwiftUI के माध्यम से प्रोग्रामेटिक रूप से वर्णित किया जाता है।

कॉम्प्लिकेशन — वॉच फ़ेस पर डेटा

कॉम्प्लिकेशन (Complication) एक विजेट है जो Apple Watch फ़ेस पर डेटा प्रदर्शित करता है। डेवलपर CLKComplicationDataSource प्रोटोकॉल लागू करता है, विभिन्न वॉच फ़ेस प्रकारों (circular, rectangular, modular, extraLarge) के लिए टेम्पलेट प्रदान करता है। watchOS 10 SwiftUI के लिए एक सरलीकृत API — ComplicationDescriptor का समर्थन करता है। डेटा 30 मिनट तक की अवधि के साथ बैकग्राउंड टास्क के माध्यम से अपडेट किया जाता है।

Watch Connectivity के माध्यम से iPhone एकीकरण

Watch Connectivity Bluetooth या Wi-Fi के माध्यम से Apple Watch और iPhone के बीच डेटा आदान-प्रदान के लिए एक फ्रेमवर्क है। यह युग्मित उपकरणों के बीच संचार का एकमात्र तरीका है। WCSession केंद्रीय वर्ग है जो सत्र का प्रबंधन करता है। iOS ऐप और watchOS एक्सटेंशन को WCSessionDelegate लागू करना होगा।

डेटा स्थानांतरण विधियाँ

Watch Connectivity चार डेटा स्थानांतरण विधियाँ प्रदान करता है: sendMessage — पुष्टि के साथ तत्काल भेजना (केवल तब काम करता है जब दोनों ऐप सक्रिय हों), transferUserInfo — डेटा शब्दकोश की बैकग्राउंड डिलीवरी, transferFile — मेटाडेटा के साथ फ़ाइल स्थानांतरण, updateApplicationContext — साझा स्थिति का सिंक्रोनाइज़ेशन। सभी विधियाँ कनेक्शन बहाल होने पर डिलीवरी की गारंटी देती हैं।

import WatchConnectivity

/// iPhone और 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: — iPhone से घड़ी पर डेटा भेजना
    func sendWorkoutData(_ data: [String: Any]) {
        guard session.isReachable else {
            // यदि घड़ी अनुपलब्ध है — संदर्भ में सहेजें
            try? session.updateApplicationContext(data)
            return
        }
        session.sendMessage(data, replyHandler: nil) { error in
            print("भेजने में त्रुटि: \(error.localizedDescription)")
        }
    }

    // MARK: — घड़ी पर डेटा प्राप्त करना
    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 सक्रिय: \(activationState.rawValue)")
    }

    // watchOS पर आवश्यक नहीं लेकिन प्रोटोकॉल के लिए अनिवार्य
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {
        session.activate()
    }
}

ConnectivityManager WCSession के साथ काम करने के लिए सिंगलटन लागू करता है। sendWorkoutData isReachable की जाँच करता है: यदि घड़ी सक्रिय है, तो डेटा sendMessage के माध्यम से तुरंत भेजा जाता है; यदि नहीं — तो विलंबित डिलीवरी के लिए applicationContext में सहेजा जाता है। प्राप्तकर्ता पक्ष पर onReceiveMessage आने वाले संदेशों को संसाधित करता है और NotificationCenter के माध्यम से ऐप को सूचित करता है।

फ़ाइल आदान-प्रदान और सिंक्रोनाइज़ेशन

transferFile बड़ी मात्रा में डेटा स्थानांतरित करने की अनुमति देता है: चित्र, ऑडियो फ़ाइलें, संग्रह। अधिकतम फ़ाइल आकार 100 MB है। फ़ाइलें प्राप्त करने वाले डिवाइस पर Inbox निर्देशिका में सहेजी जाती हैं। transferUserInfo 100 KB तक के JSON डेटा के लिए उपयुक्त है। सभी विधियाँ बैकग्राउंड में काम करती हैं: यदि डिवाइस अनुपलब्ध है, तो स्थानांतरण कतारबद्ध हो जाता है और कनेक्शन बहाल होने पर स्वचालित रूप से फिर से शुरू हो जाता है।

watchOS ऐप प्रकाशित करना

watchOS ऐप प्रकाशित करना iOS के समान नियमों का पालन करता है: Apple Developer Program सदस्यता ($99/वर्ष) और App Review मॉडरेशन पास करना आवश्यक है। ऐप को iOS ऐप के भाग के रूप में या स्टैंडअलोन ऐप के रूप में App Store Connect पर अपलोड किया जाता है।

बिल्ड और वितरण

watchOS ऐप दो तरीकों से वितरित किया जा सकता है: iOS ऐप एक्सटेंशन के रूप में (iOS ऐप बंडल में watchOS .app होता है) या स्टैंडअलोन ऐप के रूप में (iPhone के बिना डाउनलोड और चलता है)। स्टैंडअलोन मोड के लिए Info.plist में WKRunsIndependently = YES आवश्यक है। watchOS ऐप का आकार सेलुलर डाउनलोड के लिए 50 MB तक सीमित है।

App Review आवश्यकताएँ

watchOS के लिए विशेष आवश्यकताएँ: ऐप को सक्रिय iPhone के बिना सही ढंग से काम करना चाहिए (यदि स्टैंडअलोन के रूप में दावा किया गया है), इंटरफ़ेस बिना ज़ूम किए पढ़ने योग्य होना चाहिए, सभी इंटरैक्टिव तत्व कम से कम 44 पॉइंट आकार के होने चाहिए। बिल्ट-इन कार्यक्षमता की नकल करने वाले ऐप (जैसे, बिना अतिरिक्त मूल्य के हृदय गति मॉनिटर) प्रतिबंधित हैं।