Controlling HomeKit Accessories from Your Rork Max Native App — Permission and State-Sync Lessons from Indie Shipping

Step 2: Register the HMHomeManager delegate, then wait

This is where most people stumble. Right after you create HMHomeManager, homes returns an empty array. That doesn't mean "no home exists" — it means it's still syncing with iCloud to load the home layout.

The correct flow is to create the manager, register the delegate first, and wait for homeManagerDidUpdateHomes(_:) to fire.

import HomeKit
 
final class HomeController: NSObject, HMHomeManagerDelegate {
    private let manager = HMHomeManager()
    private(set) var primaryHome: HMHome?
    var onReady: (() -> Void)?
 
    override init() {
        super.init()
        // Reading homes before the delegate is set always returns empty
        manager.delegate = self
    }
 
    func homeManagerDidUpdateHomes(_ mgr: HMHomeManager) {
        // Only here is the home layout finalized
        primaryHome = mgr.primaryHome ?? mgr.homes.first
        onReady?()
    }
}

Reading manager.homes.first right after init and then worrying that "accessories never appear" is almost always this pattern. I hit the same trap in my first implementation and fixed it by waiting for the delegate.

Step 3: Find the light accessory and pull out its characteristic

Once the home layout is settled, pull the service you want to control (the light) and the characteristic representing its power and brightness out of the accessories.

func powerCharacteristic(in home: HMHome) -> HMCharacteristic? {
    for accessory in home.accessories {
        for service in accessory.services where service.serviceType == HMServiceTypeLightbulb {
            for ch in service.characteristics where ch.characteristicType == HMCharacteristicTypePowerState {
                return ch
            }
        }
    }
    return nil   // Guard against finding no lights at all
}

Mixing up serviceType and characteristicType produces a confusing failure: the write succeeds but the real light doesn't react. Power is PowerState, brightness is Brightness — checking each characteristic type one by one is the reliable path.

Step 4: Write the toggle, await the result, then update the UI

Writing to a characteristic is asynchronous. Firing writeValue and forgetting it makes the UI toggle move first while the real device doesn't, creating a state mismatch. Update the UI only after the write completes.

func setPower(_ on: Bool, _ ch: HMCharacteristic) async throws {
    try await ch.writeValue(on)          // Wait until it completes
    // Confirm the UI state only on success
    await MainActor.run { self.isOn = on }
}

At first I changed local state the instant the toggle was tapped. When a write failed, that left "the screen says on but the light is still off." After switching to await completion, this kind of support question dropped visibly.

Step 5: Subscribe to external changes to prevent drift

Lights change from outside this app too — the stock Home app or a voice command. If the state changes externally while your app is open and you don't ingest it, the display stays stale. Subscribe to characteristic updates via HMAccessoryDelegate to reflect outside changes.

extension HomeController: HMAccessoryDelegate {
    func accessory(_ accessory: HMAccessory,
                   service: HMService,
                   didUpdateValueFor ch: HMCharacteristic) {
        guard ch.characteristicType == HMCharacteristicTypePowerState else { return }
        if let value = ch.value as? Bool {
            Task { @MainActor in self.isOn = value }
        }
    }
}

To start subscribing, besides setting accessory.delegate = self, you must call enableNotification(true, for:) per characteristic. Forget this and no external change ever flows in, leaving you puzzling over why it "won't sync."

Deciding how far to build as an indie developer

With the implementation so far, the on/off toggle and ingesting external changes stay stable. Trying to cover every accessory type, though, spikes the maintenance burden. The approach I took as an indie developer was to narrow to the single type my app truly needs to sync with (here, light power) and not force support for the rest. HomeKit increases your review accountability the moment you get greedy with coverage, so for a small AdMob-centric app the cost-benefit stops adding up.

Smart-home integration looks flashy, but its essence is letting the app sit quietly alongside the user's daily life. Now that Rork Max has opened a native door, polishing one integration carefully — rather than piling on features — is what pays off. I hope this helps anyone working on the same problem.