Wearable technology and embedded systems are transforming how people track health, control smart environments, and interact with connected devices. With over a billion active iOS devices and a well-established SDK ecosystem, Apple’s platform is a top choice for developers building apps for wearables like the Apple Watch or embedded IoT hardware.

This guide breaks down four core iOS frameworks, WatchConnectivity, HealthKit, Core Bluetooth, and HomeKit, and how they support powerful app development across industries like fitness, healthcare, home automation, and industrial IoT. 

You’ll find real-world use cases, industry trends, and developer-friendly code examples throughout.

📲 WatchConnectivity: Seamless Communication Between iOS and watchOS

WatchConnectivity enables two-way communication between an iOS app and its paired Apple Watch app. It supports message passing, file transfers, and real-time data synchronization, making it essential for apps that need ongoing or background communication between the iPhone and Apple Watch.

This framework is especially valuable for health and fitness apps that rely on continuous data syncing.

Use Case:

Apps like Nike Run Club and Strava use WatchConnectivity to capture real-time heart rate and workout data from the Apple Watch and sync it with the iPhone for detailed post-workout insights. With the new HealthKit Medications API introduced at WWDC 2025, developers can now sync medication reminders and logs between devices, helping users stay consistent with their treatment plans.

Industries:

  • Health & Fitness: Real-time workout tracking and health data sync
  • Wearable Tech Startups: Enabling next-gen wearable experiences
  • Medical Monitoring: Supporting remote patient data logging and alerts

Code Example – Sending a message from iPhone to Apple Watch:

import WatchConnectivity

class ViewController: UIViewController, WCSessionDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        if WCSession.isSupported() {
            let session = WCSession.default
            session.delegate = self
            session.activate()
        }
    }

    func session(_ session: WCSession, activationDidCompleteWith activationState: WCSessionActivationState, error: Error?) {}

    func sendMessageToWatch() {
        guard WCSession.default.isReachable else { return }
        let message = ["status": "WorkoutStarted"]
        WCSession.default.sendMessage(message, replyHandler: nil) { error in
            print("Message failed: \(error.localizedDescription)")
        }
    }
}

‍

Tip: Always check .isReachable before sending a message to ensure the target device is available. This is especially important for time-sensitive data like medication notifications, where reliability matters even if the devices aren’t in close proximity.

🏃 HealthKit: Access Health and Fitness Data Securely

HealthKit is a privacy-first framework that serves as a central repository for health and fitness data from Apple Watch, iPhone, and third-party wearables. It lets your app read and write health metrics, such as steps, heart rate, sleep, and, as of WWDC 2025, medication tracking, while ensuring user consent and control at every step.

Use Case:

Apps like MyFitnessPal and Lifesum tap into HealthKit to pull step counts, calorie data, and workout history to deliver tailored insights. The new Medications API extends this by allowing apps to track medication schedules, provide reminders, and log adherence.

Industries:

  • Personal Wellness and Fitness: Smart nutrition and exercise tracking
  • Clinical Research: Collecting anonymized user data for medical studies
  • Digital Therapeutics: Supporting patients in managing chronic conditions

Code Example – Reading today’s step count:

import HealthKit

class HealthManager {
    let store = HKHealthStore()

    func requestAuthorization() {
        let readTypes: Set = [HKObjectType.quantityType(forIdentifier: .stepCount)!]

        store.requestAuthorization(toShare: nil, read: readTypes) { success, error in
            if success {
                self.readStepsToday()
            } else {
                print("Authorization failed: \(error?.localizedDescription ?? "Unknown error")")
            }
        }
    }

    func readStepsToday() {
        guard let stepType = HKQuantityType.quantityType(forIdentifier: .stepCount) else { return }

        let start = Calendar.current.startOfDay(for: Date())
        let predicate = HKQuery.predicateForSamples(withStart: start, end: Date(), options: .strictStartDate)

        let query = HKStatisticsQuery(quantityType: stepType, quantitySamplePredicate: predicate, options: .cumulativeSum) { _, result, error in
            guard let sum = result?.sumQuantity() else {
                print("No steps data: \(error?.localizedDescription ?? "Unknown error")")
                return
            }
            let steps = sum.doubleValue(for: HKUnit.count())
            print("Steps today: \(steps)")
        }

        store.execute(query)
    }
}

New Feature – Tracking Medications

The HealthKit Medications API, introduced at WWDC 2025, enables developers to help users manage prescriptions by logging doses, setting reminders, and analyzing how medications impact other metrics like sleep or heart rate.

It includes key classes such as:

  • HKUserAnnotatedMedication
  • HKMedicationConcept
  • HKMedicationDoseEvent

These APIs allow for structured medication tracking and seamless integration with other health data.

Code Example – Logging a Medication Dose

import HealthKit

class HealthManager {
    let store = HKHealthStore()

    func logMedicationDose() {
        guard let medicationType = HKObjectType.medicationType() else { return }
        
        store.requestAuthorization(toShare: [medicationType], read: nil) { success, error in
            if success {
                let medication = HKMedication(medicationName: "Aspirin", productType: "Tablet")
                let dose = HKMedicationDoseEvent(medication: medication, logStatus: .taken, doseQuantity: HKQuantity(unit: HKUnit.count(), doubleValue: 1), scheduledQuantity: nil, scheduledDate: nil)
                
                self.store.save(dose) { success, error in
                    if success {
                        print("Medication dose logged successfully")
                    } else {
                        print("Error logging medication dose: \(error?.localizedDescription ?? "Unknown error")")
                    }
                }
            } else {
                print("Authorization failed: \(error?.localizedDescription ?? "Unknown error")")
            }
        }
    }
}

‍

Privacy Tip: Request access only to the data your app needs. HealthKit enforces strict consent controls, and the Medications API adds fine-grained permission management, allowing users to trust your app with their most sensitive health information.

📡 Core Bluetooth: Connect to BLE Devices and Sensors

Core Bluetooth allows iOS apps to discover, connect to, and communicate with Bluetooth Low Energy (BLE) peripherals such as heart rate monitors, smart thermometers, and industrial sensors. It’s optimized for low-power communication, making it perfect for wearables, IoT devices, and industrial equipment.

Use Case:

A BLE-compatible heart monitor, like the Polar H10, streams real-time data to an iOS app, which can log and display the user’s heart rate, save session history, or alert for anomalies.

Industries:

  • Fitness Hardware: Connecting devices like heart rate monitors and fitness bands
  • Wearable Tech R&D: Prototyping next-gen sensors and devices
  • Industrial Automation: Monitoring machine health and performance
  • Smart Agriculture: Tracking temperature, humidity, and soil data

Code Example – Scanning and connecting to peripherals:

import CoreBluetooth

class BLEManager: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate {
    var central: CBCentralManager!
    var peripheral: CBPeripheral?

    override init() {
        super.init()
        central = CBCentralManager(delegate: self, queue: nil)
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            central.scanForPeripherals(withServices: nil)
        } else {
            print("Bluetooth not ready")
        }
    }

    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String: Any], rssi RSSI: NSNumber) {
        print("Discovered: \(peripheral.name ?? "Unknown")")
        self.peripheral = peripheral
        self.peripheral?.delegate = self
        central.connect(peripheral, options: nil)
    }

    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
        print("Connected to: \(peripheral.name ?? "Unknown")")
        peripheral.discoverServices(nil)
    }
}

‍

Performance Tip: Keep scans short and focused. Limit scanning to specific UUIDs and batch peripheral discoveries when possible. Power efficiency is critical in BLE scenarios, especially when devices run on coin-cell batteries or solar energy.

🏠 HomeKit: Build Smart Home Integrations

HomeKit provides a secure and structured way to control and automate smart home devices, including locks, lights, outlets, thermostats, and more. Since iOS 17, Apple has expanded HomeKit’s compatibility through support for the Matter standard, improving cross-brand interoperability.

At WWDC 2025, iOS 26 introduced two notable smart home additions:

  • CarPlay Smart Home Widgets: Users can now control HomeKit accessories directly from the CarPlay dashboard, adjusting lights, unlocking doors, or managing the thermostat while driving.
  • EnergyKit Framework: This new framework allows apps to monitor and optimize energy consumption using data from HomeKit-compatible smart meters and devices.

Use Case:

Apps like Eve and Home+ let users create automation scenes, remotely control lighting, and lock doors from anywhere. With CarPlay widgets, users can now manage their homes safely while on the road.

Industries:

  • Smart Homes: End-to-end home automation experiences
  • Hospitality: Smart hotel room controls via mobile apps
  • Elderly Care: Remotely managing lights, appliances, and alerts
  • Home Security: Monitoring and controlling locks, cameras, and sensors

Code Example – Turning on a smart light:

import HomeKit

class HomeControlManager: NSObject, HMHomeManagerDelegate {
    var manager = HMHomeManager()

    override init() {
        super.init()
        manager.delegate = self
    }

    func homeManagerDidUpdateHomes(_ manager: HMHomeManager) {
        guard let home = manager.homes.first else { return }
        controlLight(in: home)
    }

    func controlLight(in home: HMHome) {
        for accessory in home.accessories {
            for service in accessory.services where service.serviceType == HMServiceTypeLightbulb {
                if let powerState = service.characteristics.first(where: { $0.characteristicType == HMCharacteristicTypePowerState }) {
                    powerState.writeValue(true) { error in
                        if let error = error {
                            print("Error: \(error.localizedDescription)")
                        } else {
                            print("Light turned on!")
                        }
                    }
                }
            }
        }
    }
}

‍

Security Tip: You must enable HomeKit entitlements and test with certified accessories to meet Apple’s review requirements. Always provide fallback states and UI in case devices are unreachable or offline.

Use Cases and Market Trends Across Industries

Apple’s frameworks power a wide range of real-world applications across different sectors. Here’s a quick breakdown:

Use Cases Across Industries
Use Cases Across Industries

Stats to Know

  • Wearable Healthcare Devices: 40% of U.S. adults use wearable healthcare tech, showing growing demand for health-integrated apps.
  • IoT Device Adoption: By 2026, 60% of households are expected to use at least one IoT device.
  • Industrial IoT Growth: The industrial IoT market is projected to hit $600 billion by 2026.

Best Practices for Wearable & Embedded iOS Apps

✅ Secure Your Data

Follow Apple’s App Privacy Guidelines. Always include NSHealthShareUsageDescription and other permission usage strings in your app’s Info.plist. Clear, honest descriptions improve user trust and reduce friction during onboarding.

🔋 Optimize Battery Usage

  • Use background modes judiciously.
  • Limit BLE scanning intervals and target specific services.
  • Reduce unnecessary WatchConnectivity messages.

These optimizations are essential for wearables and embedded devices where battery life is a top priority.

📱 Design for Small Screens

  • Keep Watch apps focused on single tasks.
  • Use large buttons and avoid deep navigation trees.
  • Display clear status indicators, especially for smart home or BLE device connections.

Wrapping Up

Apple’s iOS SDKs, WatchConnectivity, HealthKit, Core Bluetooth, and HomeKit, give developers a powerful toolkit for building apps that integrate seamlessly with wearables and embedded systems.

Whether you’re syncing fitness data, managing a smart home, or connecting to industrial sensors, these frameworks offer the tools you need to build rich, reliable experiences. The 2025 WWDC updates, especially the HealthKit Medications API and iOS 26 smart home enhancements, unlock even more possibilities.

By applying best practices and using the code examples provided, you’ll be ready to develop apps that meet the growing demand for smart, connected solutions.

‍

‍Have a project in mind? Let’s build something extraordinary. Reach out or book a consultation today to get started!

  • Technologies
    Development