HubitatServer: Adds HubitatServer type and adds it to the multiplexer

XIONControlPanel/Controllers/MainViewController.swift

@@ -21,6 +21,7 @@ class MainViewController: UIViewController, SwitchesViewControllerDelegate, Serv
         super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
         
         _serverMultiplex.delegate = self
+        _serverMultiplex.addServer(HubitatServer(URL(string: "https://midna.xionsf.com:6000/apps/api/1/")!))
         _serverMultiplex.addServer(WemoServer(URL(string: "http://midna.xionsf.com:5000")!))
     }
     
@@ -203,7 +204,7 @@ class MainViewController: UIViewController, SwitchesViewControllerDelegate, Serv
     
     func serverMultiplex(_ multiplex: ServerMultiplex, didAddDevices devices: [AnyDevice])
     {
-        _switchesController.devices = devices
+        _switchesController.devices = Array(multiplex.devices)
         _updateVisualization(false)
         
         // Update connection status too, if applicable

XIONControlPanel/Controllers/SwitchesViewController.swift

@@ -122,6 +122,7 @@ class SwitchesViewController: UIViewController,
             })
             
             var snapshot = _collectionViewDataSource.snapshot()
+            snapshot.deleteItems(snapshot.itemIdentifiers(inSection: SwitchesViewController.switchCellsSectionIdentifier))
             snapshot.appendItems(self.devices.map { $0.hashValue }, toSection: SwitchesViewController.switchCellsSectionIdentifier)
             _collectionViewDataSource.apply(snapshot, animatingDifferences: false)
         }

XIONControlPanel/Models/DeviceProtocol.swift

@@ -8,15 +8,15 @@
 
 import Foundation
 
-enum DeviceState
+enum DeviceState : String, Codable
 {
-    case off
-    case on
+    case off = "off"
+    case on  = "on"
 }
 
-enum DeviceType
+enum DeviceType : String, Codable
 {
-    case `switch`
+    case `switch` = "switch"
 }
 
 protocol Device

XIONControlPanel/Models/HubitatDevice.swift

@@ -0,0 +1,47 @@
+//
+//  HubitatDevice.swift
+//  XIONControlPanel
+//
+//  Created by James Magahern on 3/14/20.
+//  Copyright © 2020 XION. All rights reserved.
+//
+
+import Foundation
+
+public struct HubitatDevice : Device
+{
+    var name:   String = ""
+    var serial: String = ""
+    var type:   DeviceType = .switch
+    var state:  DeviceState = .off
+    
+    var id: Int = -1
+    
+    enum CodingKeys: String, CodingKey {
+        case name = "label"
+        case id = "id"
+        case attributes = "attributes"
+    }
+    
+    enum AttributesKeys: String, CodingKey {
+        case power
+        case dataType
+        case `switch`
+    }
+}
+
+extension HubitatDevice : Decodable
+{
+    public init(from decoder: Decoder) throws {
+        let values = try decoder.container(keyedBy: CodingKeys.self)
+        
+        let idStr = try values.decode(String.self, forKey: .id)
+        id = Int(idStr)!
+        serial = String(format: "hubitat:%d", id)
+        
+        name = try values.decode(String.self, forKey: .name)
+        
+        let attributes = try values.nestedContainer(keyedBy: Self.AttributesKeys, forKey: .attributes)
+        state = try attributes.decode(DeviceState.self, forKey: .switch)
+    }
+}

XIONControlPanel/Servers/HubitatServer.swift

@@ -0,0 +1,82 @@
+//
+//  HubitatServer.swift
+//  XIONControlPanel
+//
+//  Created by James Magahern on 3/14/20.
+//  Copyright © 2020 XION. All rights reserved.
+//
+
+import Foundation
+import Combine
+
+class HubitatServer : Server
+{
+    var connected: Bool = false
+    
+    public fileprivate(set) var devices: [HubitatDevice] = []
+    
+    private let baseURL: URL
+    private let accessToken = "fa861583-71f0-466f-8add-f29b2278af6a"
+    private var cancellable: AnyCancellable?
+    
+    required init(_ url: URL)
+    {
+        self.baseURL = url
+    }
+    
+    func connect(_ completion: @escaping (Error?) -> Void)
+    {
+        // RESTful, assume we're connected unless we get an error
+        self.connected = true
+        completion(nil)
+    }
+    
+    func disconnect(_ completion: (Error?) -> Void)
+    {
+        self.connected = false
+    }
+    
+    func fetchDevices(_ fetchCompletion: @escaping (Result<[AnyDevice], Error>) -> Void)
+    {
+        let url = baseURL.appendingPathComponent("devices/all").authenticatedURLWithAccessToken(accessToken)
+        
+        self.cancellable = URLSession.shared.dataTaskPublisher(for: url)
+            .mapError { $0 as Error }
+            .map { $0.data }
+            .decode(type: [HubitatDevice].self, decoder: JSONDecoder())
+            .eraseToAnyPublisher()
+            .sink(receiveCompletion: { completion in
+                if case let Subscribers.Completion.failure(error) = completion {
+                    fetchCompletion(.failure(error))
+                }
+            }) { (devices: [HubitatDevice]) in
+                self.devices = devices
+                fetchCompletion(.success(devices.map { AnyDevice($0) }))
+            }
+    }
+    
+    func toggleDevice(_ device: AnyDevice, state: DeviceState, completion: @escaping (Error?) -> Void)
+    {
+        if let hubitatDevice = (self.devices.first { $0.serial == device.serial }) {
+            print("HUBITAT: Toggle: ", hubitatDevice.id)
+            
+            // TODO...
+        }
+    }
+    
+    func responsibleForDevice(_ device: AnyDevice) -> Bool
+    {
+        return self.devices.contains { $0.serial == device.serial }
+    }
+}
+
+extension URL
+{
+    func authenticatedURLWithAccessToken(_ token: String) -> URL
+    {
+        guard var components = URLComponents(url: self, resolvingAgainstBaseURL: false) else { fatalError() }
+        components.queryItems = [ URLQueryItem(name: "access_token", value: token) ]
+        
+        return components.url!
+    }
+}

XIONControlPanel/Servers/ServerMultiplex.swift

@@ -102,14 +102,7 @@ extension ServerMultiplex
     private func handleDevicesChanged(_ devicesChanged: [AnyDevice])
     {
         let newDevicesSet = Set<AnyDevice>(devicesChanged)
-        
         let additions = newDevicesSet.subtracting(self.devices)
-        if additions.count > 0 {
-            DispatchQueue.main.async {
-                self.delegate?.serverMultiplex(self, didAddDevices: Array(additions))
-            }
-        }
-        
         let changed = newDevicesSet.filter { (device: AnyDevice) in
             if let existing = (devices.first { $0.hashValue == device.hashValue }) {
                 return existing.state != device.state
@@ -118,13 +111,19 @@ extension ServerMultiplex
             return false
         }
         
+        self.devices = self.devices.union(newDevicesSet)
+        
+        if additions.count > 0 {
+            DispatchQueue.main.async {
+                self.delegate?.serverMultiplex(self, didAddDevices: Array(additions))
+            }
+        }
+        
         if changed.count > 0 {
             DispatchQueue.main.async {
                 self.delegate?.serverMultiplex(self, devicesStateChanged: Array(changed))
             }
         }
-        
-        self.devices = self.devices.union(newDevicesSet)
     }
     
     private func handleError(_ error: Error)