Skip to content

Your home as a live 3D model in the Mac menu bar and on iPhone — lights and ACs via Smart Life, Home Assistant, Philips Hue and Apple Home.

8.1 KB
Raw Blame
import Foundation
import Network

/// The Mac's side of the sync: advertises itself on the local network and hands its
/// floor plan to the iPhones that were paired with it. Nothing listens until the user
/// pairs a phone for the first time.
@MainActor
public final class SyncServer {
    private let store: SecretStore
    private var listener: NWListener?
    private var peers: [ObjectIdentifier: Peer] = [:]
    private var advertise = true
    public private(set) var pairing: SyncPairing?
    /// True once Bonjour confirmed that phones can find this Mac. It stays false when
    /// macOS has not been allowed to let the app use the local network.
    public private(set) var isAdvertised = false

    private final class Peer {
        let channel: SyncChannel
        var name = ""
        /// The plan revision this iPhone is known to hold.
        var revision = ""
        init(_ channel: SyncChannel) { self.channel = channel }
    }

    /// What to send: read every time a phone connects or `broadcast()` is called.
    public var snapshot: (() -> SyncState)?
    /// Called when a phone connects or disconnects.
    public var onPeersChanged: (() -> Void)?
    /// A phone asks the Mac to display the QR code of its own Smart Life login
    /// (`content`), or to take it down again (nil). The second argument is the phone's name.
    /// A phone that disconnects does not take its code down: it is scanned from another
    /// app on that phone, and iOS cuts the connection as soon as ours leaves the screen.
    public var onShowQR: ((String?, String) -> Void)?
    /// A phone sends the devices of its Apple Home (which only it can reach), for the editor.
    public var onCatalog: (([[String: Any]], String) -> Void)?
    /// A phone sends the floor plan it edited (the file byte for byte, already checked to be
    /// a plan) and its name. The Mac stores it and calls `broadcast()`.
    public var onPlan: ((Data, String) -> Void)?
    /// A phone sends its Home Assistant and Hue connections (see `DeviceHub.adoptConnections`)
    /// and the Smart Life User Code it signed in with, if any.
    public var onConnections: (([String: Any], String, String) -> Void)?

    /// `store` keeps the pairing (by default `sync.json` next to the plan, readable by its user only).
    public init(store: SecretStore) {
        self.store = store
        pairing = store.read().flatMap { try? JSONDecoder().decode(SyncPairing.self, from: $0) }
    }

    public var isEnabled: Bool { pairing != nil }
    /// Names of the iPhones connected right now.
    public var connectedDevices: [String] { peers.values.map(\.name).filter { !$0.isEmpty }.sorted() }
    /// The port the listener got, once it is running.
    public var port: UInt16? { listener?.port?.rawValue }

    /// Makes sure this Mac can be paired with and returns what the phone has to scan.
    @discardableResult
    public func enable(name: String) -> SyncPairing {
        guard var current = pairing else { return reset(name: name) }
        if current.name != name {
            // The Mac was renamed: same key, new name on the network and in the code.
            current.name = name
            pairing = current
            store.write(try? JSONEncoder().encode(current))
            restart()
        } else {
            start()
        }
        return current
    }

    /// New key: every phone paired so far has to be paired again.
    @discardableResult
    public func reset(name: String) -> SyncPairing {
        let fresh = SyncPairing.generate(name: name)
        pairing = fresh
        store.write(try? JSONEncoder().encode(fresh))
        restart()
        return fresh
    }

    public func disable() {
        pairing = nil
        store.write(nil)
        stop()
    }

    /// Starts listening if this Mac has been paired with before. `advertise: false` skips
    /// Bonjour, for tests that connect to the port directly.
    public func start(advertise: Bool = true) {
        self.advertise = advertise
        guard let pairing, listener == nil else { return }
        guard let listener = try? NWListener(using: SyncTransport.parameters(key: pairing.key)) else { return }
        if advertise {
            var txt = NWTXTRecord()
            txt["id"] = pairing.id
            listener.service = NWListener.Service(name: pairing.name, type: SyncTransport.serviceType, txtRecord: txt)
            listener.serviceRegistrationUpdateHandler = { [weak self] change in
                MainActor.assumeIsolated {
                    guard let self, case .add = change, !self.isAdvertised else { return }
                    self.isAdvertised = true
                    self.onPeersChanged?()
                }
            }
        }
        listener.newConnectionHandler = { [weak self] connection in
            MainActor.assumeIsolated { self?.accept(connection) }
        }
        listener.stateUpdateHandler = { [weak self] state in
            MainActor.assumeIsolated {
                // A listener that failed (network change, port lost) is replaced.
                guard let self, case .failed = state else { return }
                self.listener?.cancel()
                self.listener = nil
                self.isAdvertised = false
                DispatchQueue.main.asyncAfter(deadline: .now() + 2) { self.start(advertise: self.advertise) }
            }
        }
        self.listener = listener
        listener.start(queue: .main)
    }

    public func stop() {
        listener?.cancel()
        listener = nil
        isAdvertised = false
        for peer in peers.values { peer.channel.close() }
        peers = [:]
        onPeersChanged?()
    }

    private func restart() {
        stop()
        start(advertise: advertise)
    }

    /// Sends the current state to every connected phone (after the plan was saved, or the
    /// Smart Life account changed).
    public func broadcast() {
        guard let state = snapshot?() else { return }
        for peer in peers.values where !peer.name.isEmpty { send(state, to: peer) }
    }

    private func send(_ state: SyncState, to peer: Peer) {
        peer.channel.send(state.message(includingPlan: state.revision != peer.revision))
        peer.revision = state.revision
    }

    private func accept(_ connection: NWConnection) {
        let channel = SyncChannel(connection)
        let peer = Peer(channel)
        let key = ObjectIdentifier(channel)
        peers[key] = peer
        channel.onMessage = { [weak self, weak peer] message in
            guard let self, let peer else { return }
            self.handle(message, from: peer)
        }
        channel.onClose = { [weak self] _ in
            guard let self, let gone = self.peers.removeValue(forKey: key) else { return }
            if !gone.name.isEmpty { self.onPeersChanged?() }
        }
        channel.start()
    }

    private func handle(_ message: [String: Any], from peer: Peer) {
        switch message["type"] as? String {
        case "hello":
            let isNew = peer.name.isEmpty
            peer.name = (message["device"] as? String).flatMap { $0.isEmpty ? nil : $0 } ?? "iPhone"
            peer.revision = message["rev"] as? String ?? ""
            if let state = snapshot?() { send(state, to: peer) }
            if isNew { onPeersChanged?() }
        case "showQR":
            guard !peer.name.isEmpty else { return }
            onShowQR?(message["content"] as? String, peer.name)
        case "catalog":
            guard !peer.name.isEmpty, let devices = message["devices"] as? [[String: Any]] else { return }
            onCatalog?(devices, peer.name)
        case "plan":
            guard !peer.name.isEmpty, let text = message["plan"] as? String else { return }
            let data = Data(text.utf8)
            guard (try? PlanStore.validate(data)) != nil else { return }
            // The phone holds this revision now: the broadcast that follows need not echo it.
            peer.revision = PlanStore.revision(of: data)
            onPlan?(data, peer.name)
        case "connections":
            guard !peer.name.isEmpty, let shared = message["connections"] as? [String: Any] else { return }
            onConnections?(shared, message["userCode"] as? String ?? "", peer.name)
        default:
            break
        }
    }
}