Chapter    11

Home Automation Using HomeKit

Manny de la Torriente

Much like Apple sought to unify health data with HealthKit, HomeKit is Apple’s entry into home automation. Apple created a unified communications protocol—HomeKit Accessory Protocol— for connected home manufactures. HomeKit is a common set of APIs (application programming interfaces) for applications that provides integration between iOS devices and accessories that support the HomeKit Accessory Protocol.

This chapter explains the key concepts behind the HomeKit framework (home, room, accessory, services) and how to easily build an app that can configure, monitor, and control home automation accessories, as well as integrate with Siri for voice commands. Additionally, you’ll learn how to set up and use the HomeKit simulator to help develop and debug your application.

Introduction to HomeKit Concepts

HomeKit provides integration between iOS devices and accessories that support Apple’s HomeKit Accessory Protocol. HomeKit allows an application to discover these accessories and add them to a cross-device home configuration database where the data can then be accessed and modified to suit the needs of the end user. The database is also available to Siri, which gives the user the capability of controlling the accessories with voice commands.

A home manager is represented by the HMHomeManager class, which manages a collection of homes. It is used to access HomeKit objects such as home, room, accessory, service, and other related objects from the HomeKit database.

A home is considered to be a single-dwelling home and is represented by the HMHome class. It provides access to a collection of automated accessories with which you can communicate and configure. Each home may optionally have one or more rooms. HomeKit will assign accessories to a default room if you have not configured any rooms. A room is represented by the HMRoom class. A zone is an arbitrary optional grouping of rooms that a user considers a single area; for example, upstairs or downstairs. Rooms can be added to one or more zones. A zone is represented by the HMZone class.

An accessory is a physical home automation device that is assigned to a room, such as a ceiling fan. An accessory is represented by the HMAccessory class, and can provide one or more services; for example, a ceiling fan has a service to turn the fan on and off, and another service that can change the speed of the fan. A service can be a user-controllable function provided by an accessory, like a light, or it can be an activity internal to a device, such as a firmware update. HomeKit is most concerned with user-controllable services. A service is represented by the HMService class.

Each service is described by a collection of characteristics; for example, if a light is on or off, or what the brightness value is set to. A characteristic is represented by the HMCharacteristic class and is described by an array of properties and metadata. Characteristics can be queried to discover their state, or they can be modified to affect an accessory’s behavior.

HomeKit Delegation Methods

Like many other Apple frameworks, HomeKit uses the delegation pattern for the notification of events or changes in the application. An important note about HomeKit delegation is that when your application initiates a change, the delegate messages won’t be sent to your app. Instead, they are sent to other apps that might be running on your iOS device that also support HomeKit. For example, you might purchase a thermostat that includes an app to control it. You would want to see any changes you make in your app reflected in the thermostat app or vice versa. Your app is expected to use completion handlers to reload data and update views. However, you still need to add code to both the completion handler and the associated delegate methods. Applications need to be in the foreground to receive delegate messages, as they are not batched while your app is in the background. When an app comes back to the foreground it will receive a homeManagerDidUpdateHomes message which signals your app to reload all its data.

Building a HomeKit Application

The application you’ll create in this chapter will use grouped table views to present information. The app will provide a simple user interface (UI) for creating homes, browsing for and adding accessories, and controlling the accessories in a home, such as a ceiling fan with services for turning the fan off and on, as well as for changing the rotation speed and the rotation direction. When you’re finished, your app should look similar to the one in Figure 11-1.

Requirements

HomeKit is a service that is only available to applications that are distributed through the App Store, so you must have the ability to provision and code-sign your app. To do so, you’ll need the following:

• Membership in the iOS developer program.
• Permission to create code signing and provisioning assets in the member center.

HomeKit Accessory Simulator

Apple provides a HomeKit Accessory Simulator to help you develop your HomeKit apps. The simulator communicates with an iOS device the same way an actual HomeKit accessory would using the HomeKit Accessory Protocol (HAP) over Bluetooth Low Energy (LE) or Wi-Fi, so there’s no need buy specific hardware to develop your app. With the simulator, you can create accessories with services and add characteristics to those services.

The simulator is not provided with Xcode, so you’ll have to download it from the developer’s web site at https://developer.apple.com/downloads/ (Figure 11-2). Click the download button in the HomeKit row. Alternatively, from the menu, Xcode Open Developer Tools More Developer Tools . . ., which will also open the browser and display the same page.

Search for Hardware IO Tools and select the download which is compatible with your version of Xcode. Once downloaded, double-click the .dmg file, and drag HomeKit Accessory Simulator to the /Applications folder. Later on in this chapter, you’ll use the simulator to build and test your app.

Creating the Project

We will create an iOS single-view application Xcode project named HomeKitApp. Select Swift as the Language and use the defaults for Language and Devices (see Figure 11-3). You can use HomeKit-enabled accessories with your iPhone, iPad, and iPod touch.

Choose the HomeKitApp target from the Targets list and click the General tab to view the General pane (Figure 11-4). In the lower portion of the Identity section, click the Team pop-up menu and select your profile.

Enabling HomeKit

HomeKit requires an explicit App ID which is created when you enable HomeKit. Click the Capabilities tab and locate the HomeKit row (see Figure 11-5). Click the switch to the ON position to enable HomeKit. Notice that a new file named HomeKitApp.entitlements was added to your project.

Building the Homes Interface

There is one HomeKit database per home. A collection of homes are managed by an HMHomeManager object. You’ll use the home manager to add homes, retrieve a list of homes, track changes to homes, and remove homes. You’ll start out by building an interface that will support adding one or more homes and the means to assign a primary home. A grouped table view will work well for this.

The table view controller will use sections to present a list of user-defined homes. The first section will be used to add and remove homes. The user can also select a home from that section to configure and control. The second section will display the available homes and allow the user to assign the primary home. At runtime, the table will look similar to the illustration shown in Figure 11-6.

Open the storyboard, then delete the current view controller and replace it with a table view controller. Select the table view controller, then from the Attributes Inspector, set it as the initial view controller for the storyboard by setting the check box Is initial view controller. Embed the table view controller in a navigation controller by selecting the table view controller and then from Xcode menu choose Editor Embed In Navigation Controller. From the Documents Outline on the left, select the Table View object and change its style to Grouped in the Attributes Inspector. Set the title for the navigation item in the table view controller to Homes. Your storyboard should look similar to the one Figure 11-7.

In order to track changes to a collection of one or more homes, you’ll need to implement the HMHomeManagerDelegate protocol. The home manager will notify its delegate when there are any changes to the home configuration.

Begin by changing the class declaration for your new custom table view controller (see Listing 11-1). From the navigator, change the name of the file ViewController.swift to HomesViewController.swift, then change the name of the class to HomesViewController, the parent class to UITableViewController, and add the protocol for HMHomeManagerDelegate.

class HomesViewController: UITableViewController, HMHomeManagerDelegate {
}

Then in the storyboard, set the Custom Class for the table view controller to HomesViewController in the Identity Inspector (Figure 11-8).

Implementing the Home Manager Delegate Methods

The home manager communicates changes when homes are added, when they are removed, or when significant changes are made to the home configuration. These changes are communicated through the following delegate methods:

• didAddHome: Tells the delegate that the home manager added a home.
• didRemoveHome: Tells the delegate that the home manager updated its collection of homes.
• homeManagerDidUpdateHomes: Tells the delegate that the home manager updated its collection of homes.

Implement these methods in HomesViewController (see Listing 11-2). In the homeManagerDidUpdateHomes method call tableView.reloadData().

class HomesViewController: UITableViewController, HMHomeManagerDelegate {

    // MARK: HMHomeManagerDelegate methods

    func homeManagerDidUpdateHomes(manager: HMHomeManager) {
        print("homeManagerDidUpdateHomes")
        tableView.reloadData()
    }

    func homeManager(manager: HMHomeManager, didAddHome home: HMHome) {
        print("didAddHome (home.name)")
    }

    func homeManager(manager: HMHomeManager, didRemoveHome home: HMHome) {
        print("didRemoveHome (home.name)")
    }
}

Instantiating the HMHomeManager

For the purposes of this application, you’ll utilize the singleton pattern to provide a global point of access to an HMHomeManager object as well as the current selected HMHome object. Create a new file named HomeStore.swift and add the code from Listing 11-3.

import HomeKit

class HomeStore: NSObject {

    static let sharedInstance = HomeStore()

    var homeManager: HMHomeManager = HMHomeManager()
    var home: HMHome?
}

Listing 11-4 updates the HomesViewController to define a computed property homeStore and then assign self as the home manager delegate.

class HomesViewController: UITableViewController, HMHomeManagerDelegate {

    var homeStore: HomeStore {
        return HomeStore.sharedInstance
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        homeStore.homeManager.delegate = self
    }

The HomesViewController will be responsible for setting the value of the HomeStore.home to reflect the current home, based on user input.

Setting Up the Table View

Open the storyboard and add four custom prototype cells to the Homes table view as shown in Figure 11-9.

At the top of the HomesViewController class body, add a structure named Identifiers and define a constant property for each of the prototype cells. The cells are listed in the same order as shown in Listing 11-5.

struct Identifiers {
    static let addHomeCell = "AddHomeCell"
    static let noHomesCell = "NoHomesCell"
    static let primaryHomeCell = "PrimaryHomeCell"
    static let homeCell = "HomeCell"
}

Now in the storyboard using the Attributes Inspector, assign each of the custom table view cells to the corresponding reuse identifier from the Identifiers struct. This is the same reuse identifier you will send to the table view in the dequeueReusableCellWithIdentifier message. Make sure you assign Checkmark in the Accessory pop-up window for the PrimaryHomeCell shown in Figure 11-10.

Implementing UITableView Methods

At the top of the HomesViewController class body, add an enum named HomeSections with values for Homes and PrimaryHome. These values correspond to the IndexPath.section index number which is passed in as a parameter to table view delegate methods and will be used to identify a specified section of a UITableView object (Listing 11-6).

enum HomeSections: Int {
    case Homes = 0, PrimaryHome
    static let count = 2
}

To help determine which type of table row is associated with a table view section, use the helper method shown in Listing 11-7. The isHomesListEmpty method simply returns whether or not the homes count equals zero, and the isIndexPathAddHome method returns true if the specified row in the homes section is the last row.

// MARK: UITableView helpers

func isHomesListEmpty() -> Bool {
    return homeStore.homeManager.homes.count == 0
}

func isIndexPathAddHome(indexPath: NSIndexPath) -> Bool {
    return indexPath.section == HomeSections.Homes.rawValue
        && indexPath.row == homeStore.homeManager.homes.count
}

The value of the HomeSections count, which is currently defined at 2, determines the number of sections in the table view (see Listing 11-8).

// MARK: UITableView methods

override func numberOfSectionsInTableView(tableView: UITableView) -> Int {
    return HomeSections.count
}

The number of rows in a section will be dependent on which section of the table view is specified. In the case where the section is PrimaryHome, the number of rows value should be at least 1. In the case where the section is Homes, the number should always return the actual count plus 1. This guarantees that there will always be at least one row in each of the sections to accommodate the AddHome . . . and No Homes cells (see Listing 11-9 and Figure 11-11).

override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {

    let count = homeStore.homeManager.homes.count

    switch (section) {
    case HomeSections.PrimaryHome.rawValue:
        return max(count, 1)
    case HomeSections.Homes.rawValue:
        return count + 1
    default:
        break
    }

    return 0
}

The delegate method cellForRowAtIndexPath returns a UITableViewCell object that corresponds to the specified row and section. In the case where the row/section corresponds to a row which contains a home defined by the user, the reuse identifier is set based on whether or not the home section is for the primary home. The cell object is then initialized with the home name and corresponding cell accessory type (see Listing 11-10).

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {

    if isIndexPathAddHome(indexPath) {
        return tableView.dequeueReusableCellWithIdentifier(Identifiers.addHomeCell, forIndexPath: indexPath)
    } else if isHomesListEmpty() {
        return tableView.dequeueReusableCellWithIdentifier(Identifiers.noHomesCell, forIndexPath: indexPath)
    }

    var reuseIdentifier: String?

    switch (indexPath.section) {
    case HomeSections.PrimaryHome.rawValue:
        reuseIdentifier = Identifiers.primaryHomeCell
    case HomeSections.Homes.rawValue:
        reuseIdentifier = Identifiers.homeCell
    default:
        break
    }

    let cell = tableView.dequeueReusableCellWithIdentifier(reuseIdentifier!, forIndexPath: indexPath) as UITableViewCell

    let home = homeStore.homeManager.homes[indexPath.row] as HMHome
    cell.textLabel?.text = home.name

    if indexPath.section == HomeSections.PrimaryHome.rawValue {
        if home == homeStore.homeManager.primaryHome {
            cell.accessoryType = .Checkmark
        } else {
            cell.accessoryType = .None
        }
    }

    return cell
}

Listing 11-11 indicates that the section for the primary home has a header and a footer.

override func tableView(tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
    if section == HomeSections.PrimaryHome.rawValue {
        return "Primary Home"
    }
    return nil
}

override func tableView(tableView: UITableView, titleForFooterInSection section: Int) -> String? {
    if section == HomeSections.PrimaryHome.rawValue {
        return "Used by Siri to route commands when a home is not specified"
    }
    return nil
}

Adding a New Home to the Home Manager

When the user selects the table row labeled Add Home . . ., the onAddHomeTouched method is invoked from the didSelectRowAtIndexPath method and the user is presented with a simple UIAlertController prompting for a name. Once you enter a valid name, the home is added using the home manager method addHomeWithName (see Listing 11-12).

self.homeStore.homeManager.addHomeWithName(homeName, completionHandler: { home, error in
    if error != nil {
        print("failed to add new home. (error)")
    } else {
        print("added home (home!.name)")
        self.tableView.reloadData()
    }
})

On success, the table view is refreshed, and the new home appears in the list. If the home is the first home, it’s assigned as the primary home. You can find the complete method in Listing 11-13.

private func onAddHomeTouched() {

    let controller = UIAlertController(title: "Add Home", message: "Enter a name for the home", preferredStyle: .Alert)

    controller.addTextFieldWithConfigurationHandler({ textField in
        textField.placeholder = "My House"
    })

    controller.addAction(UIAlertAction(title: "Cancel", style: .Cancel, handler: nil))

    controller.addAction(UIAlertAction(title: "Add Home", style: .Default) { action in
        let textFields = controller.textFields as [UITextField]!
        if let homeName = textFields[0].text {

            if homeName.isEmpty {
                let alert = UIAlertController(title: "Error", message: "Please enter a name", preferredStyle: .Alert)
                alert.addAction(UIAlertAction(title: "Dismiss", style: .Default, handler: nil))
                self.presentViewController(alert, animated: true, completion: nil)

            } else {
                self.homeStore.homeManager.addHomeWithName(homeName, completionHandler: { home, error in
                    if error != nil {
                        print("failed to add new home. (error)")
                    } else {
                        print("added home (home!.name)")
                        self.tableView.reloadData()
                    }
                })
            }
        }
    })
    presentViewController(controller, animated: true, completion: nil)
}

Setting the Primary Home

When the user selects a home listed in the Primary Home section, the home manager’s updatePrimaryHome method is called (Listing 11-14). The completion handler reloads the table view if the call succeeded.

homeStore.homeManager.updatePrimaryHome(home, completionHandler: { error in
    if let error = error {
        UIAlertController.showErrorAlert(self, error: error)
    } else {
        let indexSet = NSIndexSet(index: HomeSections.PrimaryHome.rawValue)
        tableView.reloadSections(indexSet, withRowAnimation: .Automatic)
    }
})

Siri Integration

Siri recognizes home, room, zone, accessory, and characteristic names. Siri uses the primary home when the command does not specify a home name.

Setting the Current Home

When the user selects a home listed in the first section, the current home is set in the home store.

homeStore.home = homeStore.homeManager.homes[indexPath.row]

The view will then transition to a detailed view for the home where the user can configure or control its accessories.

override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {

    if isIndexPathAddHome(indexPath) {
        tableView.deselectRowAtIndexPath(indexPath, animated: true)
        onAddHomeTouched()

    } else {
        homeStore.home = homeStore.homeManager.homes[indexPath.row]
        if HomeSections(rawValue: indexPath.section) == .PrimaryHome {
            let home = homeStore.homeManager.homes[indexPath.row]
            if home != homeStore.homeManager.primaryHome {
                homeStore.homeManager.updatePrimaryHome(home, completionHandler: { error in
                    if let error = error {
                        UIAlertController.showErrorAlert(self, error: error)
                    } else {
                        let indexSet = NSIndexSet(index: HomeSections.PrimaryHome.rawValue)
                        tableView.reloadSections(indexSet, withRowAnimation: .Automatic)
                    }
                })
            }
        }
    }
}

Removing an Existing Home

When you swipe a table row, it enters into editing mode. The table view invokes its canEditRowAtIndexPath method where the application can determine on a row-by-row basis to allow editing.

override func tableView(tableView: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
    return !isIndexPathAddHome(indexPath)
        && !isHomesListEmpty()
        && indexPath.section == HomeSections.Homes.rawValue
}

If editing is allowed for a row, the row displays a Delete button. If the user taps the Delete button, the view controller receives a commitEditingStyle message from the table view. If the editingStyle is Delete, removeHome can be called on the home manager.

let home = homeStore.homeManager.homes[indexPath.row] as HMHome
homeStore.homeManager.removeHome(home, completionHandler: { error in
})

In the completion block, if there is no error, tableView.deleteRowsAtIndexPaths is called. See Listing 11-17 for the complete method.

override func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {

    if (editingStyle == .Delete) {

        let home = homeStore.homeManager.homes[indexPath.row] as HMHome
        homeStore.homeManager.removeHome(home, completionHandler: { error in

            if error != nil {
                print("Error (error)")
                return

            } else {
                tableView.beginUpdates()
                    let primaryIndexPath = NSIndexPath(forRow: indexPath.row, inSection: HomeSections.PrimaryHome.rawValue)
                    if self.homeStore.homeManager.homes.count == 0 {
                        tableView.reloadRowsAtIndexPaths([primaryIndexPath], withRowAnimation: UITableViewRowAnimation.Fade)
                    } else {
                        tableView.deleteRowsAtIndexPaths([primaryIndexPath], withRowAnimation: .Automatic)
                    }
                    tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
                tableView.endUpdates()
            }
        })
    }
}

Security

When home manager has been called for the first time on a device, it will alert the user and ask for permission to access the user’s accessory data.

Selecting “Don’t Allow” (Figure 11-12) prevents HomeKit from providing information to your application, in which case the settings will have to be changed in the Settings.app in the Privacy/Homekit section.

If the user is signed into an iCloud account on the device but hasn’t enabled the iCloud keychain, HomeKit will prompt the user to turn on the iCloud keychain to allow access from the user’s other devices.

Building the Home Interface

The Home scene will display all the accessories that are associated with the selected home. It will also provide the means to add discoverable accessories. For this scene, you will need a table view that uses a standard prototype cell and a navigation bar item to invoke an accessory browser.

The Home table scene will use a grouped table view to present a list of accessories for the selected home. The Add (+) navigation bar item will open an accessory browser. Selecting an accessory from the browser will add the accessory to the current home, then send a notification and return to the Home scene. The HomeViewController will handle the notification and refresh the view. When you select an accessory from the table, the scene will transition to the Services scene where accessories can be controlled.

At runtime, the table will look similar to the illustrations in Figure 11-13. The first view is empty; the second is populated with three accessories.

Open the storyboard and add a new UITableViewController to the storyboard canvas.

Select the table view and in the Attributes Inspector, change the style to Grouped.

Select the table view cell (Figure 11-14) and in the Attributes Inspector, change its style to Subtitle; Identifier to AccessoryCell; Accessory type to Detail Disclosure.

Now add a segue from the HomeCell of the HomesViewController to the new table view controller you’ve just added (see Figure 11-15).

Notice a navigation bar was automatically added for you. Change the navigation bar title to Home (see Figure 11-16).

Next, add a Bar Button Item to the navigation bar. From the Attributes Inspector in the Bar Button Item section, change the System Item Add so that a plus (+) symbol is displayed. This control will be used to invoke an Accessory Browser, which you’ll build in the section “Building the Accessory Browser” (see Figure 11-26).

Create a new Swift file named HomeViewController.swift. Declare a new class HomeViewController that subclasses UITableViewController and adopt the protocol for HMHomeDelegate, and then define computed properties for homeStore and home (see Listing 11-18).

class HomeViewController: UITableViewController, HMHomeDelegate {

    var homeStore: HomeStore {
        return HomeStore.sharedInstance
    }
    var home: HMHome! {
        return homeStore.home
    }
}

In the storyboard set the custom class for the table view controller to HomeViewController in the Identity Inspector.

Assign self as the current home delegate, and set the view controller’s title to the name of the current home in the viewDidLoad method after the line with super.viewDidLoad() (see Listing 11-4).

home?.delegate = self
title = homeStore.home!.name

Implement the home manager delegate methods didAddAccessory and didRemoveAccessory such that the table view is updated when changes are made by other HomeKit apps (see Listing 11-19).

// MARK: HMHomeDelegate methods

func home(home: HMHome, didAddAccessory accessory: HMAccessory) {
    print("didAddAccessory (accessory.name)")
    tableView.reloadData()
}

func home(home: HMHome, didRemoveAccessory accessory: HMAccessory) {
    print("didRemoveAccessory (accessory.name)")
    tableView.reloadData()
}

Signaling Changes within the Application

Remember, your app is expected to use completion handlers to reload data and update its views. A convenient method is the use of NSNotificationCenter.

In the HomeStore class, add a constant for AddAccessoryNotification at the top of the class body as shown in Listing 11-20.

struct Notification {
    static let AddAccessoryNotification = "AddAccessoryNotification"
}

In the viewDidLoad method of the HomeStore class, add the following line shown in 11-21 to register an observer for the AddAccessoryNotification.

NSNotificationCenter.defaultCenter().addObserver(self,
    selector: "updateAccessories",
    name: HomeStore.Notification.AddAccessoryNotification, object: nil)

Add a new method shown in Listing 11-22, which will be used for the notification selector. This method will reload the data for the table view when the notification is received.

func updateAccessories() {
    print("updateAccessories selector called from NSNotificationCenter")
    tableView.reloadData()
}

Implementing More UITableView Methods

There will be two sections in the Home table view. The first section will be used as the “Accessories” section heading, and the second is for the accessories list (see Listing 11-23).

override func numberOfSectionsInTableView(tableView: UITableView) -> Int {

    if homeStore.home?.accessories.count == 0 {
        setBackgroundMessage("No Accessories")
    } else {
        setBackgroundMessage(nil)
    }
    return 2
}

A background message is also set in the numberOfSectionsInTableView method if the table is empty; otherwise no message is displayed (see Listing 11-24).

private func setBackgroundMessage(message: String?) {
    if let message = message {
        let label = UILabel()
        label.text = message
        label.font = UIFont.preferredFontForTextStyle(UIFontTextStyleBody)
        label.textColor = UIColor.lightGrayColor()
        label.textAlignment = .Center
        label.sizeToFit()
        tableView.backgroundView = label
        tableView.separatorStyle = .None
    }
    else {
        tableView.backgroundView = nil
        tableView.separatorStyle = .SingleLine
    }
}

The number of rows in the first section of table view is 0, as only the section heading is displayed. The number of rows in the second section is determined by the number of accessories associated with the current home (see Listing 11-25).

override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    if section == 1 {
        return homeStore.home!.accessories.count
    }
    return 0
}

The data source for the table is a list of accessories that are assigned to the current home. Each row maps to an element in the accessories list. Accessories are added by the Accessory Browser (see Listing 11-26).

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
    let accessory = homeStore.home!.accessories[indexPath.row];
    let reuseIdentifier = "AccessoryCell"

    let cell = tableView.dequeueReusableCellWithIdentifier(reuseIdentifier, forIndexPath: indexPath)
    cell.textLabel?.text = accessory.name

    let accessoryName = accessory.name
    let roomName = accessory.room!.name
    let inIdentifier = NSLocalizedString("%@ in %@", comment: "Accessory in Room")
    cell.detailTextLabel?.text = String(format: inIdentifier, accessoryName, roomName)
    return cell
}

override func tableView(tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
    if section == 0 {
        return homeStore.home?.accessories.count != 0 ? "Accessories" : “”
    }
    return nil
}

Removing an Accessory from a Home

When an accessory table row is swiped, the table enters into editing mode. The table view invokes its canEditRowAtIndexPath method where the application can determine on a row-by-row basis to allow editing. In this case, the accessories list row is always editable (see Listing 11-28).

override func tableView(tableView: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
    if indexPath.section == 1 {
        return true
    }
    return false
}

If editing is allowed for a row, the row displays a Delete button. If the user taps the Delete button, the view controller receives a commitEditingStyle message from the table view (see Listing 11-29). If the editingStyle is Delete, then removeAccessory can be called on the current home. In the completion block, if there is no error, tableView.deleteRowsAtIndexPaths is called.

override func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {

    if (editingStyle == .Delete) {

        let accessory = homeStore.home?.accessories[indexPath.row]
        homeStore.home?.removeAccessory(accessory!, completionHandler: { error in
            if error != nil {
                print("Error (error)")
                UIAlertController.showErrorAlert(self, error: error!)

            } else {
                tableView.beginUpdates()
                    let rowAnimation = self.homeStore.home?.accessories.count == 0 ? UITableViewRowAnimation.Fade : UITableViewRowAnimation.Automatic
                    tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: rowAnimation)
                tableView.endUpdates()
                tableView.reloadData()
            }
        })
    }
}

Using the HomeKit Accessory Simulator

The HomeKit Accessory Simulator is a developer tool that allows you to define accessories for which you don’t have a physical accessory. You can create accessories and add services and characteristics to closely represent physical devices. For example, you can define a ceiling fan and then add services to turn power on and off and change the rotation speed and rotation direction. From your application, you can scan for and add the accessories you define in the simulator, and then control the services just as you would with a physical accessory. The simulator allows you to pair with a device, change values, and receive changed values. So when you flip a switch in your app you can see the result immediately in the simulator, and vice versa; if you change values in the simulator, it sends the changed values to your app.

You can start by creating a lamp accessory. Launch the simulator (/Applications/HomeKit Accessory Simulator.app) and then, located in the lower left corner of the app, click the Add button (+) and select New Accessory from the pop-up. When prompted, enter a name and manufacturer for accessory and leave the default for serial number as shown in Figure 11-17. Click the Finish button.

You should see a new accessory item in the left panel under IP Accessories, and the main view on the right where you can add services and characteristics (see Figure 11-18).

Your new lamp accessory needs a service with characteristics that you can control from your app. Select your accessory from the list on the left side of the window, and then click the Add Service button located in the upper portion of the main view. From the options pop-up, click the Service pull-down, select Lightbulb Service, and then click the Finish button (see Figure 11-19). The new service appears in the detail view.

The simulator automatically creates a common characteristic for each service type, so for the lamp accessory you just created, an On characteristic was added for you (Figure 11-20). Some characteristics are mandatory, like the On power switch, but if you wanted to add an additional characteristic like a dimmer, for example, you would click the Add Characteristic button and add a Brightness characteristic from the Characteristic pull-down in the options pop-up.

You now have an accessory that can be discovered and controlled from your app. Later in this chapter, you’ll add support to browse for available accessories.

Pairing with a New Accessory

In your application when you attempt to add a new accessory, the system will present an Add HomeKit Accessory dialog that states that the accessory is not certified. This is allowed when using the HomeKit Accessory Simulator, so click the Add Anyway button (see Figure 11-21).

The system will present a screen that asked you to provide a setup code for the accessory. Click the Enter code manually button located at the bottom of Figure 11-22.

Another screen is presented that allows you to enter an eight-digit code. Enter the setup code from the simulator’s main view detail area below the accessory name (Figure 11-23).

The system displays a progress indicator while it processes the setup code. If you entered the wrong code (or selected cancel), you will be presented with a screen that allows you to enter the code again. If you entered the correct code, the system presents a screen that states that the accessory was added and is ready to use (Figure 11-24).

Building the Accessory Browser

The accessory browser is used to scan for HomeKit-enabled accessories. The scene will use a grouped table view to present a list of HomeKit-enabled accessories that are not already associated with the selected home.

At runtime, the table will look similar to the illustration in Figure 11-25.

Open the storyboard and drag a new navigation controller from the Object library onto the storyboard canvas. A new UITableViewController will automatically be added to the storyboard canvas.

Change the title of the table view navigation item to Accessory Browser.

Select the table view and in the Attributes Inspector and change the style to Grouped.

Select the table view cell and in the Attributes Inspector, change its style to Subtitle and Identifier to AccessoryCell.

Drag a View from the Object library and insert it above the table view cell.

Add a Label to the view you just added and set the text to Searching for new accessories.

Add an Activity View Indicator to the right of the label you just added. The Accessory Browser Scene in the Document outline should look similar to the one in Figure 11-26.

Add a Bar Button Item to the navigation bar. From the Attributes Inspector in the Bar Button Item section, change the System Item to Done. This control will be used to dismiss the Accessory Browser.

Your Accessory Browser scene should look similar to the illustration in Figure 11-27.

Create a new Swift file named AccessoryBrowser.swift. Declare a new class AccessoryBrowser that subclasses UITableViewController and adopts the protocol for HMAccessoryBrowserDelegate (see Listing 11-30). Add the properties accessoryBrowser, accessories, and selectedAccessory.

class AccessoryBrowser: UITableViewController, HMAccessoryBrowserDelegate {

    let accessoryBrowser = HMAccessoryBrowser()
    var accessories = [HMAccessory]()
    var selectedAccessory: HMAccessory?
}

In the storyboard set the Custom Class for the table view controller to AccessoryBrowser in the Identity Inspector.

Assign self as the accessory browser delegate in the viewDidLoad method after the line with super.viewDidLoad().

accessoryBrowser.delegate = self

Implement the accessory browser delegate methods didFindNewAccessory and didRemoveNewAccessory such that the specified accessory is added or removed from the table view (see Listing 11-31). When adding a new accessory, check that it doesn’t already exist.

// MARK: HMAccessoryBrowserDelegate methods

func accessoryBrowser(browser: HMAccessoryBrowser, didFindNewAccessory accessory: HMAccessory) {
    print("didFindNewAccessory (accessory.name)")
    if !self.accessories.contains(accessory) {
        self.accessories.insert(accessory, atIndex: 0)
        let indexPath = NSIndexPath(forRow: 0, inSection: 0)
        tableView.insertRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
    }
}

func accessoryBrowser(browser: HMAccessoryBrowser, didRemoveNewAccessory accessory: HMAccessory) {
    print("didRemoveNewAccessory (accessory.name)")
    if let index = accessories.indexOf(accessory) {
        let indexPath = NSIndexPath(forRow: index, inSection: 0)
        accessories.removeAtIndex(index)
        tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
    }
}

Scanning for Accessories

To start scanning for available accessories, call the accessory browser’s startSearchingForNewAccessories method. In this example app, it’s called from the viewDidLoad method of the view controller.

accessoryBrowser.startSearchingForNewAccessories()

To stop searching, call the accessory browser’s stopSearchingForNewAccessories method. The example app calls this from the viewWillDisappear method of the view controller.

override func viewWillDisappear(animated: Bool) {
    accessoryBrowser.stopSearchingForNewAccessories()
}

Implementing UITableView Methods

The data source for the table is a list of accessories that are assigned to the current home. Each row maps to an element in the accessories list.

The number of rows is determined by the number of available accessories (Listing 11-32).

override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    return accessories.count
}

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
    let accessory = accessories[indexPath.row];
    let cell = tableView.dequeueReusableCellWithIdentifier("AccessoryCell", forIndexPath: indexPath)
    cell.textLabel?.text = accessory.name
    cell.detailTextLabel?.text = accessory.category.localizedDescription
    return cell
}

Reload the table data from the viewWillAppear method of the view controller of the AccessoryBrowser class as shown in Listing 11-34.

override func viewWillAppear(animated: Bool) {
    super.viewWillAppear(animated)
    tableView.reloadData()
}

Adding a New Accessory to the Home

When the user selects an accessory from the list, the table view delegate method didSelectRowAtIndexPath is called. Assign the selectedAccessory to the corresponding element in the assessor’s list.

selectedAccessory = accessories[indexPath.row]

To add the accessory to the current home, you call the home objects addAccessory method as shown in Listing 11-35, and pass in the selectedAccessory as the parameter. The completion block is executed after the request is processed. The value of error will be nil on success.

When the accessory has been successfully added to the home, post a notification so any registered observers can update their views (see Listing 11-35).

To assign the new accessory to a room, you call the home objects assignAccessory method and pass in the selectedAccessory along with the room to which the accessory will be assigned. The accessory must already have been added to the home. The room must already exist in the home. In this example, the default room for the home is being used. Later, you can extend the application and provide support to add new rooms (see Listing 11-35).

override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {

    tableView.deselectRowAtIndexPath(indexPath, animated: true)

    selectedAccessory = accessories[indexPath.row]
    HomeStore.sharedInstance.home?.addAccessory(self.selectedAccessory!, completionHandler: { error in

        if (error != nil) {
            print("Error: (error)")
            UIAlertController.showErrorAlert(self, error: error!)

        } else {
            NSNotificationCenter.defaultCenter().postNotificationName(HomeStore.Notification.AddAccessoryNotification, object: nil)
            HomeStore.sharedInstance.home?.assignAccessory(self.selectedAccessory!, toRoom: (HomeStore.sharedInstance.home?.roomForEntireHome())!, completionHandler: { error in
                if let error = error {
                    print("failed to assign accessory to room: (error)")
                } else {
                    print("added (self.selectedAccessory!.name) to room")
                }
            })
        }

    })
}

Dismissing the Accessory Browser

To dismiss the accessory browser and return to the Home scene, create an action connection (see Listing 11-36). Control-drag from the Done Button Bar Item control to the implementation file. In the Connection pop-up, set the name of the action to done and then click Connect. Add a call to dismissViewControllerAnimated.

@IBAction func done(sender: AnyObject) {
    dismissViewControllerAnimated(true, completion: nil)
}

Building the Services Interface

The Services scene will display all the services that are available for a specific accessory. Each service will be presented in its own section followed by a list of associated characteristics.

At runtime, the table will look similar to the illustration in Figure 11-28.

Open the storyboard and add a new UITableViewController to the storyboard canvas.
Select the table view and in the Attributes Inspector, change the style to Grouped.

Add two labels to the table view cell and position them on the left in Figure 11-29. From the Attributes Inspector, change the font for the top label to Footnote and the bottom label to Body.

Select the table view and, from the Attributes Inspector, change the number of prototype cells to four. You should see four identical cells.

Change the table view cell identifier for the first cell to CharacteristicCell.

Change the table view cell identifier for the second cell to PowerStateCell, and then add a UISwitch and position it on the right side.

Change the table view cell identifier for the third cell to SliderCell, and then add a UISlider and position it to the right.

Change the table view cell identifier for the fourth cell to SegmentedCell. Remove the second label and replace it with a UISegmentedControl, and then position it so that your result appears as in Figure 11-30.

Your Services scene should now look similar to the illustration shown in Figure 11-30.

Create a new Swift file named ServicesViewController.swift. Declare a new class ServicesViewController that subclasses IUTableViewController and adopt the protocol for HMAccessoryDelegate as shown in Listing 11-37.

class ServicesViewController: UITableViewController, HMAccessoryDelegate {
}

In the storyboard, set the custom class for the table view controller to ServicesViewController in the Identity Inspector.

Add a stored property called services and initialize it with a new, empty array of HMService values.

var services = [HMService]()

Add a stored property called accessory to hold a HMAccessory and define a property observer to set self as delegate (see Listing 11-38).

var accessory: HMAccessory? {
    didSet {
        accessory?.delegate = self
    }
}

In the viewDidLoad method, set the view controller’s title to the accessory’s name.

title = "(accessory!.name) Services"

Configuring Services

Recall that each service will be presented in its own section followed by a list of its characteristics. The first section will show information about the accessory, so you’ll need to iterate through the services for the accessory, checking its type. Insert the service of type HMServiceTypeAccessoryInformation at the front of the array. Call the configureServices method shown in Listing 11-39 from the viewDidLoad method.

private func configureServices() {

    for service in accessory!.services as [HMService] {
        if service.serviceType == HMServiceTypeAccessoryInformation {
            services.insert(service, atIndex: 0)
        } else {
            services.append(service)
        }
    }
}

Receiving Value Change Notifications for Characteristics

To display the current state of a services characteristic, you’ll want to receive notifications when the characteristic’s value changes. You do this by calling the enableNotification method for a characteristic that supports notifications. You can check this by testing if the characteristics properties contain the constant HMCharacteristicPropertySupportsEventNotification. You want to selectively turn notifications on or off, so create a method called enableNotifications that takes a Boolean as a parameter (see Listing 11-40).

private func enableNotifications(enable: Bool) {
    for service in services {
        for characteristic in service.characteristics {
            if characteristic.properties.contains(HMCharacteristicPropertySupportsEventNotification) {
                characteristic.enableNotification(enable, completionHandler: { error in
                    if let error = error {
                        print("Failed to enable notifications for (characteristic): (error.localizedDescription)")
                    }
                })
            }
        }
    }
}

You’ll want to call enableNotifications(true) to enable notifications from the viewDidLoad method after you’ve set up the services array and call enableNotifications(false) to disable notifications from the viewWillDisappear method.

Implementing UITableView Methods

The data source for the table view will be the services array, so the number of sections in the table is determined by the number of services, and the number of rows for each section is determined by the number of characteristics for each service (Listing 11-41).

override func numberOfSectionsInTableView(tableView: UITableView) -> Int {
    return services.count
}

override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    return services[section].characteristics.count
}
Set the title for the section to the service name.

override func tableView(tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
    return services[section].name
}

The cell style presented for each row is determined by the properties and metadata of a characteristic. Character properties are represented by the following constants:

• HMCharacteristicPropertySupportsEventNotification: The characteristic supports notifications using the event connections established by the controller.
• HMCharacteristicPropertyReadable: The characteristic is readable.
• HMCharacteristicPropertyWritable: The characteristic is writable.

Characteristic metadata is information that further describes a characteristic’s value. Character metadata is represented by the HMCharacteristicMetadata object. You query the metadata to find out information such as the data format, units, numeric value ranges, and manufacturer’s descriptions.

In the delegate method cellForRowAtIndexPath, evaluate each characteristic to determine the cell style (see Listing 11-42).

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {

    var reuseIdentifier = Identifiers.CharacteristicCell

    let characteristic = services[indexPath.section].characteristics[indexPath.row]

    if characteristic.isReadOnly || characteristic.isWriteOnly {
        reuseIdentifier = Identifiers.CharacteristicCell
    } else if characteristic.isBoolean {
        reuseIdentifier = Identifiers.PowerStateCell
    } else if characteristic.hasValueDescriptions {
        reuseIdentifier = Identifiers.SegmentedCell
    } else if characteristic.isNumeric {
        reuseIdentifier = Identifiers.SliderCell
    }

    let cell = tableView.dequeueReusableCellWithIdentifier(reuseIdentifier, forIndexPath: indexPath)
    if let cell = cell as? CharacteristicCell {
        cell.characteristic = characteristic
    }

    return cell
}

At the top of the ServicesViewController class, define a structure named Identifiers with properties for each cell prototype in the table (see Listing 11-43).

struct Identifiers {
    static let CharacteristicCell = "CharacteristicCell"
    static let PowerStateCell = "PowerStateCell"
    static let SliderCell = "SliderCell"
    static let SegmentedCell = "SegmentedCell"
}
...

Create a new file named HMCharacteristicExtension.swift and declare a new extension for HMCharacteristic. The purpose of this extension is to provide stored properties and constants that can be used that help determine data formats, units, and such by inspecting a characters properties and metadata (see Listing 11-44).

import HomeKit

extension HMCharacteristic {

    private struct Const {
        static let numberFormatter = NSNumberFormatter()

        static let numericFormats = [
            HMCharacteristicMetadataFormatInt,
            HMCharacteristicMetadataFormatFloat,
            HMCharacteristicMetadataFormatUInt8,
            HMCharacteristicMetadataFormatUInt16,
            HMCharacteristicMetadataFormatUInt32,
            HMCharacteristicMetadataFormatUInt64
        ]
    }

    var isReadOnly: Bool {
        return !properties.contains(HMCharacteristicPropertyWritable)
            && properties.contains(HMCharacteristicPropertyReadable)
    }

    var isWriteOnly: Bool {
        return !properties.contains(HMCharacteristicPropertyReadable)
            && properties.contains(HMCharacteristicPropertyWritable)
    }

    var isBoolean: Bool {
        guard let metadata = metadata else { return false }
        return metadata.format == HMCharacteristicMetadataFormatBool
    }

    var isNumeric: Bool {
        guard let metadata = metadata else { return false }
        guard let format = metadata.format else { return false }
        return Const.numericFormats.contains(format)
    }

    var isFloatingPoint: Bool {
        guard let metadata = metadata else { return false }
        return metadata.format == HMCharacteristicMetadataFormatFloat
    }

    var isInteger: Bool {
        return self.isNumeric && !self.isFloatingPoint
    }

    var hasValueDescriptions: Bool {
        guard let number = self.value as? Int else { return false }
        return self.descriptionForNumber(number) != nil
    }

    var valueDescription: String {
        if let value = self.value {
            return descriptionForValue(value)
        }
        return “”
    }

    var unitDecoration: String {
        if let units = self.metadata?.units {
            switch units {
            case HMCharacteristicMetadataUnitsPercentage: return "%"
            case HMCharacteristicMetadataUnitsFahrenheit: return "°F"
            case HMCharacteristicMetadataUnitsCelsius: return "°C"
            case HMCharacteristicMetadataUnitsArcDegree: "°"
            default:
                break
            }
        }
        return “”
    }

    var valueCount: Int {
        guard let metadata = metadata, minimumValue = metadata.minimumValue as? Int else { return 0 }
        guard let maximumValue = metadata.maximumValue as? Int else { return 0 }
        var range = maximumValue - minimumValue
        if let stepValue = metadata.stepValue as? Double {
            range = Int(Double(range) / stepValue)
        }
        return range + 1
    }

    var allValues: [AnyObject]? {
        guard self.isInteger else { return nil }
        guard let metadata = metadata, stepValue = metadata.stepValue as? Double else { return nil }
        let choices = Array(0..<self.valueCount)
        return choices.map { choice in
            Int(Double(choice) * stepValue)
        }
    }

    func descriptionForValue(value: AnyObject) -> String {
        if self.isWriteOnly {
            return "Write-Only"

        } else if let metadata = self.metadata {
            if metadata.format == HMCharacteristicMetadataFormatBool {
                if let boolValue = value.boolValue {
                    return boolValue ? "On" : "Off"
                }
            }
        }

        if let intValue = value as? Int {
            if let desc = self.descriptionForNumber(intValue) {
                return desc
            }
            if let stepValue = self.metadata?.stepValue {
                Const.numberFormatter.minimumFractionDigits = Int(log10(1.0 / stepValue.doubleValue))
                if let string = Const.numberFormatter.stringFromNumber(intValue) {
                    return string + self.unitDecoration
                }
            }
        }

        return "(value)"
    }

    func descriptionForNumber(number: Int) -> String? {
        switch self.characteristicType {
        case HMCharacteristicTypePowerState, HMCharacteristicTypeInputEvent, HMCharacteristicTypeOutputState:
            return Bool(number) ? "On" : "Off"

        case HMCharacteristicTypeObstructionDetected:
            return Bool(number) ? "Yes" : "No"

        case HMCharacteristicTypeTargetDoorState, HMCharacteristicTypeCurrentDoorState:
            if let state = HMCharacteristicValueDoorState(rawValue: number) {
                switch state {
                case .Open: return "Open"
                case .Opening: return "Opening"
                case .Closed: return "Closed"
                case .Closing: return "Closing"
                case .Stopped: return "Stopped"
                }
            }

        case HMCharacteristicTypePositionState:
            if let state = HMCharacteristicValuePositionState(rawValue: number) {
                switch state {
                case .Opening: return "Opening"
                case .Closing: return "Closing"
                case .Stopped: return "Stopped"
                }
            }

        case HMCharacteristicTypeRotationDirection:
            if let dir = HMCharacteristicValueRotationDirection(rawValue: number) {
                switch dir {
                case .Clockwise: return "Clockwise"
                case .CounterClockwise: return "Counter Clockwise"
                }
            }
        default:
            break
        }
        return nil
    }
}

Subclass UITableViewCell for Characteristics

Characteristic Information

Create a new file named CharacteristicCell.swift and declare a new class CharacteristicCell that subclasses UITableViewCell. This will act at the base class for all characteristic table view cells (see Listing 11-45).

import HomeKit

class CharacteristicCell: UITableViewCell {

    @IBOutlet weak var typeLabel: UILabel!
    @IBOutlet weak var valueLabel: UILabel!

    var characteristic: HMCharacteristic! {
        didSet {
            var desc = characteristic.localizedDescription
            if characteristic.isReadOnly {
                desc = desc + " (Read Only)"
            } else if characteristic.isWriteOnly {
                desc = desc + " (Write Only)"
            }
            typeLabel.text = desc
            valueLabel?.text = "No Value"

            setValue(characteristic.value, notify: false)

            selectionStyle = characteristic.characteristicType == HMCharacteristicTypeIdentify ? .Default : .None

            if characteristic.isWriteOnly {
                return
            }

            if reachable {
                characteristic.readValueWithCompletionHandler { error in
                    if let error = error {
                        print("Error reading value for (self.characteristic): (error)")
                    } else {
                        self.setValue(self.characteristic.value, notify: false)
                    }
                }
            }
        }
    }

    var value: AnyObject?

    var reachable: Bool {
        return (characteristic.service?.accessory?.reachable ?? false)
    }

    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
    }

    func setValue(newValue: AnyObject?, notify: Bool) {
        self.value = newValue
        if let value = self.value {
            self.valueLabel?.text = self.characteristic.descriptionForValue(value)
        }

        if notify {
            self.characteristic.writeValue(self.value, completionHandler: { error in
                if let error = error {
                    print("Failed to write value for (self.characteristic): (error.localizedDescription)")
                }
            })
        }
    }
}

Power State Control

Create a new file named PowerStateCell.swift and declare a new class PowerStateCell that subclasses CharacteristicCell. A UISwitch is used to toggle the value that represents a characteristics power state (see Listing 11-46).

import HomeKit

class PowerStateCell: CharacteristicCell {

    @IBOutlet weak var powerSwitch: UISwitch!

    @IBAction func switchValueChanged(sender: UISwitch) {
        setValue(powerSwitch.on, notify: true)
    }

    override var characteristic: HMCharacteristic! {
        didSet {
            powerSwitch.userInteractionEnabled = reachable
        }
    }

    override func setValue(newValue: AnyObject?, notify: Bool) {
        super.setValue(newValue, notify: notify)
        if let newValue = newValue as? Bool where !notify {
            powerSwitch.setOn(newValue, animated: true)
        }
    }
}

Slider Control

Create a new file named SliderCell.swift and declare a new class SliderCell that subclasses CharacteristicCell. A UISlider control is used to change a characteristic’s numeric value (see Listing 11-47).

import HomeKit

class SliderCell: CharacteristicCell {

    @IBOutlet weak var slider: UISlider!

    @IBAction func sliderValueChanged(sender: UISlider) {
        let value = roundedValueForSliderValue(slider.value)
        setValue(value, notify: true)
    }

    override var characteristic: HMCharacteristic! {
        didSet {
            slider.userInteractionEnabled = reachable
        }

        willSet {
            slider.minimumValue = newValue.metadata?.minimumValue as? Float ?? 0.0
            slider.maximumValue = newValue.metadata?.maximumValue as? Float ?? 100.0
        }
    }

    override func setValue(newValue: AnyObject?, notify: Bool) {
        super.setValue(newValue, notify: notify)
        if let newValue = newValue as? NSNumber where !notify {
            slider.value = newValue.floatValue
        }
    }

    private func roundedValueForSliderValue(value: Float) -> Float {
        if let metadata = characteristic.metadata,
            stepValue = metadata.stepValue as? Float where stepValue > 0 {
                let newValue = roundf(value / stepValue)
                let stepped = newValue * stepValue
                return stepped
        }
        return value
    }
}

Segmented Control

Create a new file named SegmentedCell.swift and declare a new class SegmentedCell that subclasses CharacteristicCell. A UISegmentedControl is used to represent a range of values that represents descriptions.

import HomeKit

class SegmentetCell: CharacteristicCell {

    @IBOutlet weak var segmentedControl: UISegmentedControl!

    @IBAction func segmentValueChanged(sender: UISegmentedControl) {
        let value = titleValues[segmentedControl.selectedSegmentIndex]
        setValue(value, notify: true)
    }

    var titleValues = [Int]() {
        didSet {
            segmentedControl.removeAllSegments()
            for index in 0..<titleValues.count {
                let value: AnyObject = titleValues[index]
                let title = self.characteristic.descriptionForValue(value)
                segmentedControl.insertSegmentWithTitle(title, atIndex: index, animated: false)
            }
        }
    }

    override var characteristic: HMCharacteristic! {
        didSet {
            segmentedControl.userInteractionEnabled = reachable

            if let values = self.characteristic.allValues as? [Int] {
                titleValues = values
            }
        }
    }

    override func setValue(newValue: AnyObject?, notify: Bool) {
        super.setValue(newValue, notify: notify)
        if !notify {
            if let intValue = value as? Int, index = titleValues.indexOf(intValue) {
                segmentedControl.selectedSegmentIndex = index
            }
        }
    }
}

Accessory Delegate Methods

When a characteristic value of an accessory changes, the accessory notifies its delegate through the didUpdateValueForCharacteristic method (see Listing 11-49). The accessory parameter represents the object for which the characteristic value has changed. The service parameter represents the service with a changed characteristic value. The characteristic parameter represents the characteristic whose value changed.

// MARK: HMAccessoryDelegate methods

func accessory(accessory: HMAccessory, service: HMService, didUpdateValueForCharacteristic characteristic: HMCharacteristic) {
    if let index = service.characteristics.indexOf(characteristic) {
        let indexPath = NSIndexPath(forRow: index, inSection: 1)
        let cell = tableView.cellForRowAtIndexPath(indexPath) as! CharacteristicCell
        cell.setValue(characteristic.value, notify: false)
    }
}

Transitioning to the Services Scene

Add a segue to transition to the Services scene when the user selects an accessory from the table. Open the storyboard and control-drag from the Home scene table view cell to the services view controller. Set the segue identifier to ServicesSegue.

In the HomeViewController class, override the prepareForSegue method and set the accessory property of the ServicesViewController (see Listing 11-50).

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
    if segue.identifier == "ServicesSegue" {
        let controller = segue.destinationViewController as! ServicesViewController
        let indexPath = tableView.indexPathForSelectedRow;
        controller.accessory = homeStore.home!.accessories[(indexPath?.row)!];
    }
}

Running the Application

Build and run the application. Add a new home; you should see a new entry in the first table section. You should also see an entry with that home name in the Primary Home section with a check mark to the right side of the cell. Now add a second home; you should see a second entry in the first table section as well as in the second section. The first home added should still be marked as the Primary Home. Select the second home in the Primary Home section; the check mark should now appear to the right of the table cell indicating that the second home is now the Primary Home.

Adding Accessories

• Select a home from the first section; the app should transition to a view with the home name shown in the navigation bar and an empty table view. The background should show a label with the text No Accessories.
• Tap the (+) Add button in the navigation bar; the view should transition to the Accessory Browser. If you’ve added any accessories to the simulator, you should list them here.
• Select an accessory from the list; a pop-up should appear warning that the accessory is not certified and may not work reliably with HomeKit. This is normal when using the simulator.
• Select Add Anyway; you should be presented with a scene prompting you for an eight-digit accessory setup code.
• Tap the Enter code manually text at the bottom of the view; you should be presented with a scene that has a keypad where you can enter the eight-digit accessory setup code which can be found in the simulator app at the top of the main view.
• Enter the code; if you’ve entered the incorrect code, you should see the message Adding Failed. If you’ve entered the correct code then the message Accessory Added will appear briefly and the view should automatically transition back to the Accessory Browser. Notice that the accessory you selected is no longer listed in the table view.
• Tap the Done button in the navigation bar; you should now see the accessory listed in the home view.
• Select the accessory in the table view; you should transition to the Services scene. The accessory name should appear as the title in the navigation bar. You should see several table sections. The first section is informative only. It should show the same information as shown in the simulator. The second table section should be labeled with the service name. There will be one or more table cells, one for each characteristic, with a control that can be used to change the value or state of the characteristic. For example, if you see a Lightbulb service, there should be a switch available to turn the power on and off.
• Change the state of the characteristic; notice that the associated value in the simulator changes as well.
• Change the value from the simulator; notice the associated value in your app changes.

Experiment with the simulator by adding more accessories and then add the accessories to the homes you have in your app. Notice that you can’t add an accessory to more than one home.

Summary

This chapter covered some of the basic concepts of HomeKit and how you can use the HomeKit framework in an application. It also covered the basics for using The HomeKit Accessory Simulator to help you develop and test your application.

There’s so much more that can be done. The sample app only scratches the surface of what can be done using the HomeKit framework. It’s up to you to extend the functionality to accommodate your needs.