@tempivo/sensor-beacon 1.1.2 → 1.1.4

package/ios/Sources/TempivoSensorBeacon/EfentoRawConfigTransfer.swift

@@ -0,0 +1,601 @@
+import Foundation
+import CoreBluetooth
+
+/// Wire-level ProtoConfig transfer (get 0x0C / set 0x0D).
+///
+/// One persistent central/peripheral link is reused across commands. Creating a new
+/// `CBCentralManager` per command made the second command race the previous teardown,
+/// so notifications never arrived and the transfer timed out.
+///
+/// Disconnect the vendor SDK session before calling: two CB stacks cannot share one peripheral.
+enum EfentoRawConfigTransfer {
+  fileprivate static let transferService = CBUUID(string: "6E20F700-6126-4FCD-99C1-EB8A182501A2")
+  fileprivate static let transferWrite = CBUUID(string: "6E20F701-6126-4FCD-99C1-EB8A182501A2")
+  fileprivate static let transferNotify = CBUUID(string: "6E20F702-6126-4FCD-99C1-EB8A182501A2")
+  fileprivate static let primaryService = CBUUID(string: "69E1F600-BC3C-4DC0-8127-CFCDD295C7F7")
+  fileprivate static let primaryWrite = CBUUID(string: "69E1F601-BC3C-4DC0-8127-CFCDD295C7F7")
+  fileprivate static let primaryNotify = CBUUID(string: "69E1F602-BC3C-4DC0-8127-CFCDD295C7F7")
+
+  fileprivate static let hdrReq: UInt8 = 0xAA
+  fileprivate static let hdrRsp: UInt8 = 0x55
+  fileprivate static let cmdGetConfig: UInt8 = 0x0C
+  fileprivate static let cmdSetConfig: UInt8 = 0x0D
+  fileprivate static let notifyConfiguration: UInt8 = 0x03
+
+  private static let link = Link()
+
+  static func readProtoConfig(
+    peripheralId: UUID,
+    bluetoothMac: String,
+    pin: String,
+    timeoutSeconds: TimeInterval = 25
+  ) throws -> Data {
+    try link.runCommand(
+      peripheralId: peripheralId,
+      bluetoothMac: bluetoothMac,
+      pin: pin,
+      writeProto: nil,
+      timeoutSeconds: timeoutSeconds
+    )
+  }
+
+  /// Write full ProtoConfig (command 0x0D). Payload = be3 PIN + proto bytes (SDK / Python layout).
+  static func writeProtoConfig(
+    peripheralId: UUID,
+    bluetoothMac: String,
+    pin: String,
+    proto: Data,
+    timeoutSeconds: TimeInterval = 25
+  ) throws {
+    _ = try link.runCommand(
+      peripheralId: peripheralId,
+      bluetoothMac: bluetoothMac,
+      pin: pin,
+      writeProto: proto,
+      timeoutSeconds: timeoutSeconds
+    )
+  }
+
+  /// Drop the persistent link (call when the JS session disconnects).
+  static func closeLink() {
+    link.close()
+  }
+
+  // MARK: - Persistent link
+
+  private final class Link: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate {
+    private let bleQueue = DispatchQueue(label: "com.tempivo.sensor.rawConfig")
+
+    private var central: CBCentralManager?
+    private var peripheral: CBPeripheral?
+    private var writeChar: CBCharacteristic?
+    private var notifyChar: CBCharacteristic?
+    private var usingTransfer = true
+    private var discoveryStarted = false
+
+    // Per-command state.
+    private var targetId: UUID?
+    private var bluetoothMac = ""
+    private var pin = ""
+    private var writeProto: Data?
+    private var notifyChunks: [Data] = []
+    private var startResponse: Data?
+    private var commandSent = false
+    private var finished = true
+    private var commandToken = UUID()
+    private var onDone: ((Result<Data, Error>) -> Void)?
+
+    private var cmd: UInt8 {
+      writeProto == nil ? EfentoRawConfigTransfer.cmdGetConfig : EfentoRawConfigTransfer.cmdSetConfig
+    }
+
+    func runCommand(
+      peripheralId: UUID,
+      bluetoothMac: String,
+      pin: String,
+      writeProto: Data?,
+      timeoutSeconds: TimeInterval
+    ) throws -> Data {
+      var lastError: Error?
+      for attempt in 0..<2 {
+        do {
+          return try attemptCommand(
+            peripheralId: peripheralId,
+            bluetoothMac: bluetoothMac,
+            pin: pin,
+            writeProto: writeProto,
+            timeoutSeconds: timeoutSeconds
+          )
+        } catch {
+          lastError = error
+          // Drop the link so the retry starts from a clean connect.
+          close()
+          if attempt == 0 { Thread.sleep(forTimeInterval: 1.0) }
+        }
+      }
+      throw lastError ?? TempivoSensorError(.unknown, "Raw config transfer failed.")
+    }
+
+    func close() {
+      bleQueue.sync {
+        if let central, let peripheral {
+          central.cancelPeripheralConnection(peripheral)
+        }
+        self.peripheral = nil
+        self.writeChar = nil
+        self.notifyChar = nil
+        self.discoveryStarted = false
+        self.central = nil
+        self.finished = true
+        self.onDone = nil
+      }
+    }
+
+    private func attemptCommand(
+      peripheralId: UUID,
+      bluetoothMac: String,
+      pin: String,
+      writeProto: Data?,
+      timeoutSeconds: TimeInterval
+    ) throws -> Data {
+      let sem = DispatchSemaphore(value: 0)
+      var result: Result<Data, Error>!
+      let token = UUID()
+
+      bleQueue.async {
+        self.commandToken = token
+        self.targetId = peripheralId
+        self.bluetoothMac = bluetoothMac
+        self.pin = pin
+        self.writeProto = writeProto
+        self.notifyChunks = []
+        self.startResponse = nil
+        self.commandSent = false
+        self.finished = false
+        self.onDone = { r in
+          result = r
+          sem.signal()
+        }
+        if self.central == nil {
+          self.central = CBCentralManager(delegate: self, queue: self.bleQueue)
+        } else {
+          self.advance()
+        }
+        self.bleQueue.asyncAfter(deadline: .now() + timeoutSeconds) {
+          guard self.commandToken == token else { return }
+          self.fail(TempivoSensorError(.unknown, "Raw config BLE timeout."))
+        }
+      }
+
+      sem.wait()
+      return try result.get()
+    }
+
+    /// Drive connect → discover → notify → command. Safe to call repeatedly.
+    private func advance() {
+      guard !finished, let central, let targetId else { return }
+      guard central.state == .poweredOn else { return }
+
+      if peripheral == nil || peripheral?.identifier != targetId {
+        guard let found = central.retrievePeripherals(withIdentifiers: [targetId]).first else {
+          fail(TempivoSensorError(.connectFailed, "Peripheral not in cache. Scan first, then connect."))
+          return
+        }
+        peripheral = found
+        found.delegate = self
+        writeChar = nil
+        notifyChar = nil
+        discoveryStarted = false
+      }
+      guard let peripheral else { return }
+
+      switch peripheral.state {
+      case .connected:
+        break
+      case .connecting:
+        return
+      default:
+        central.connect(peripheral, options: nil)
+        return
+      }
+
+      guard let writeChar, let notifyChar else {
+        if !discoveryStarted {
+          discoveryStarted = true
+          peripheral.discoverServices([
+            EfentoRawConfigTransfer.transferService,
+            EfentoRawConfigTransfer.primaryService,
+          ])
+        }
+        return
+      }
+      guard notifyChar.isNotifying else {
+        peripheral.setNotifyValue(true, for: notifyChar)
+        return
+      }
+      if !commandSent {
+        commandSent = true
+        sendCommand(peripheral: peripheral, writeChar: writeChar)
+      }
+    }
+
+    private func sendCommand(peripheral: CBPeripheral, writeChar: CBCharacteristic) {
+      guard let pinBytes = EfentoRawConfigTransfer.pinPayloadBe3(pin) else {
+        fail(TempivoSensorError(.invalidPin, "PIN must be numeric (be3)."))
+        return
+      }
+      let payload: Data
+      if let writeProto {
+        // Set 0x0D requires be3 PIN + proto (SDK / Python).
+        payload = pinBytes + writeProto
+      } else {
+        // Get 0x0C: empty PIN payload after SDK pairing (Python --pin-payload empty).
+        payload = Data()
+      }
+      let frame = EfentoRawConfigTransfer.buildCommandFrame(
+        mac: bluetoothMac,
+        cmd: cmd,
+        payload: payload
+      )
+      let maxWrite = peripheral.maximumWriteValueLength(for: .withResponse)
+      if frame.count > maxWrite {
+        fail(TempivoSensorError(
+          .invalidConfig,
+          "Config frame is \(frame.count) B but this link accepts \(maxWrite) B per write."
+        ))
+        return
+      }
+      peripheral.writeValue(frame, for: writeChar, type: .withResponse)
+      let token = commandToken
+      bleQueue.asyncAfter(deadline: .now() + 0.35) { [weak self] in
+        guard let self, self.commandToken == token, !self.finished,
+              let writeChar = self.writeChar else { return }
+        peripheral.readValue(for: writeChar)
+      }
+      if writeProto != nil {
+        bleQueue.asyncAfter(deadline: .now() + 0.8) { [weak self] in
+          guard let self, self.commandToken == token else { return }
+          self.finishWriteIfReady()
+        }
+      } else {
+        bleQueue.asyncAfter(deadline: .now() + 1.0) { [weak self] in
+          guard let self, self.commandToken == token else { return }
+          self.tryAssemble()
+        }
+      }
+    }
+
+    /// Keep the link connected so the next command reuses it.
+    private func succeed(_ data: Data) {
+      guard !finished else { return }
+      finished = true
+      onDone?(.success(data))
+      onDone = nil
+    }
+
+    private func fail(_ error: Error) {
+      guard !finished else { return }
+      finished = true
+      onDone?(.failure(error))
+      onDone = nil
+    }
+
+    // MARK: CBCentralManagerDelegate
+
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+      guard central.state == .poweredOn else {
+        if central.state != .unknown && central.state != .resetting {
+          fail(TempivoSensorError(.runtimeUnavailable, "Bluetooth is not powered on."))
+        }
+        return
+      }
+      advance()
+    }
+
+    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
+      writeChar = nil
+      notifyChar = nil
+      discoveryStarted = false
+      advance()
+    }
+
+    func centralManager(
+      _ central: CBCentralManager,
+      didFailToConnect peripheral: CBPeripheral,
+      error: Error?
+    ) {
+      fail(error ?? TempivoSensorError(.connectFailed, "Raw BLE connect failed."))
+    }
+
+    func centralManager(
+      _ central: CBCentralManager,
+      didDisconnectPeripheral peripheral: CBPeripheral,
+      error: Error?
+    ) {
+      writeChar = nil
+      notifyChar = nil
+      discoveryStarted = false
+      if !finished {
+        fail(error ?? TempivoSensorError(.connectFailed, "Sensor dropped the config link."))
+      }
+    }
+
+    // MARK: CBPeripheralDelegate
+
+    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
+      if let error {
+        fail(error)
+        return
+      }
+      let services = peripheral.services ?? []
+      if let transfer = services.first(where: { $0.uuid == EfentoRawConfigTransfer.transferService }) {
+        usingTransfer = true
+        peripheral.discoverCharacteristics(
+          [EfentoRawConfigTransfer.transferWrite, EfentoRawConfigTransfer.transferNotify],
+          for: transfer
+        )
+        return
+      }
+      if let primary = services.first(where: { $0.uuid == EfentoRawConfigTransfer.primaryService }) {
+        usingTransfer = false
+        peripheral.discoverCharacteristics(
+          [EfentoRawConfigTransfer.primaryWrite, EfentoRawConfigTransfer.primaryNotify],
+          for: primary
+        )
+        return
+      }
+      fail(TempivoSensorError(.unsupportedCommand, "No sensor config GATT service."))
+    }
+
+    func peripheral(
+      _ peripheral: CBPeripheral,
+      didDiscoverCharacteristicsFor service: CBService,
+      error: Error?
+    ) {
+      if let error {
+        fail(error)
+        return
+      }
+      let chars = service.characteristics ?? []
+      if usingTransfer {
+        writeChar = chars.first(where: { $0.uuid == EfentoRawConfigTransfer.transferWrite })
+        notifyChar = chars.first(where: { $0.uuid == EfentoRawConfigTransfer.transferNotify })
+      } else {
+        writeChar = chars.first(where: { $0.uuid == EfentoRawConfigTransfer.primaryWrite })
+        notifyChar = chars.first(where: { $0.uuid == EfentoRawConfigTransfer.primaryNotify })
+      }
+      guard writeChar != nil, notifyChar != nil else {
+        fail(TempivoSensorError(.unsupportedCommand, "Missing write/notify characteristics."))
+        return
+      }
+      advance()
+    }
+
+    func peripheral(
+      _ peripheral: CBPeripheral,
+      didUpdateNotificationStateFor characteristic: CBCharacteristic,
+      error: Error?
+    ) {
+      if let error {
+        fail(error)
+        return
+      }
+      advance()
+    }
+
+    func peripheral(
+      _ peripheral: CBPeripheral,
+      didWriteValueFor characteristic: CBCharacteristic,
+      error: Error?
+    ) {
+      if let error {
+        fail(error)
+      }
+    }
+
+    func peripheral(
+      _ peripheral: CBPeripheral,
+      didUpdateValueFor characteristic: CBCharacteristic,
+      error: Error?
+    ) {
+      if let error {
+        fail(error)
+        return
+      }
+      guard !finished, let value = characteristic.value, !value.isEmpty else { return }
+      if characteristic.uuid == writeChar?.uuid {
+        startResponse = value
+        if writeProto != nil {
+          finishWriteIfReady()
+        }
+        return
+      }
+      if writeProto == nil, characteristic.uuid == notifyChar?.uuid {
+        notifyChunks.append(value)
+        tryAssemble()
+      }
+    }
+
+    // MARK: Frame handling
+
+    private func finishWriteIfReady() {
+      guard writeProto != nil, let startResponse else { return }
+      do {
+        _ = try EfentoRawConfigTransfer.parseStartResponse(
+          mac: bluetoothMac,
+          cmd: cmd,
+          frame: startResponse
+        )
+        succeed(Data())
+      } catch {
+        fail(error)
+      }
+    }
+
+    private func tryAssemble() {
+      if let startResponse {
+        do {
+          _ = try EfentoRawConfigTransfer.parseStartResponse(
+            mac: bluetoothMac,
+            cmd: cmd,
+            frame: startResponse
+          )
+        } catch {
+          // Some FW still streams notify after a soft status; keep assembling.
+        }
+      }
+      do {
+        let merged = try EfentoRawConfigTransfer.assemble(
+          mac: bluetoothMac,
+          chunks: notifyChunks,
+          preferCode03: usingTransfer
+        )
+        if !merged.isEmpty {
+          succeed(merged)
+        }
+      } catch {
+        // Wait for more chunks until timeout.
+      }
+    }
+  }
+
+  // MARK: - Wire helpers
+
+  fileprivate static func pinPayloadBe3(_ pin: String) -> Data? {
+    let digits = pin.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard let n = UInt64(digits), n <= 0xFFFFFF else { return nil }
+    return Data([
+      UInt8((n >> 16) & 0xFF),
+      UInt8((n >> 8) & 0xFF),
+      UInt8(n & 0xFF),
+    ])
+  }
+
+  fileprivate static func macBytes(_ mac: String) throws -> Data {
+    let h = mac.replacingOccurrences(of: ":", with: "")
+      .replacingOccurrences(of: "-", with: "")
+      .lowercased()
+    guard h.count == 12, h.allSatisfy({ $0.isHexDigit }) else {
+      throw TempivoSensorError(.invalidQr, "Invalid Bluetooth MAC.")
+    }
+    var out = Data()
+    var i = h.startIndex
+    while i < h.endIndex {
+      let j = h.index(i, offsetBy: 2)
+      out.append(UInt8(h[i..<j], radix: 16)!)
+      i = j
+    }
+    return out
+  }
+
+  fileprivate static func crc16Ccitt(_ data: Data) -> UInt16 {
+    var crc: UInt16 = 0xFFFF
+    for byte in data {
+      for bit in 0..<8 {
+        let inp = ((byte >> (7 - bit)) & 1) == 1
+        let cbit = ((crc >> 15) & 1) == 1
+        crc = (crc << 1) & 0xFFFF
+        if cbit != inp { crc ^= 0x1021 }
+      }
+    }
+    return crc
+  }
+
+  fileprivate static func buildCommandFrame(mac: String, cmd: UInt8, payload: Data) -> Data {
+    let m = (try? macBytes(mac)) ?? Data(count: 6)
+    var body = Data([hdrReq, cmd])
+    body.append(payload)
+    let crc = crc16Ccitt(m + body)
+    body.append(UInt8((crc >> 8) & 0xFF))
+    body.append(UInt8(crc & 0xFF))
+    return body
+  }
+
+  fileprivate static func parseStartResponse(mac: String, cmd: UInt8, frame: Data) throws -> Data {
+    guard frame.count >= 5 else {
+      throw TempivoSensorError(.unknown, "Short config response.")
+    }
+    if frame[0] == 0x66 {
+      throw TempivoSensorError(.unknown, "Encrypted config response (key required).")
+    }
+    guard frame[0] == hdrRsp else {
+      throw TempivoSensorError(.unknown, "Unexpected config response header.")
+    }
+    guard frame[1] == cmd else {
+      throw TempivoSensorError(.unknown, "Config command echo mismatch.")
+    }
+    let m = try macBytes(mac)
+    let expect = crc16Ccitt(m + frame.dropLast(2))
+    let got = (UInt16(frame[frame.count - 2]) << 8) | UInt16(frame[frame.count - 1])
+    guard expect == got else {
+      throw TempivoSensorError(.unknown, "Config response CRC mismatch.")
+    }
+    let st = frame[2]
+    guard st == 0 else {
+      throw TempivoSensorError(.invalidPin, "Config command status \(st).")
+    }
+    return Data(frame[3..<(frame.count - 2)])
+  }
+
+  fileprivate static func assemble(mac: String, chunks: [Data], preferCode03: Bool) throws -> Data {
+    let m = try macBytes(mac)
+    var buf = Data()
+    var merged = Data()
+    var complete = false
+
+    func crcValid(_ frame: Data) -> Bool {
+      guard frame.count >= 4 else { return false }
+      let expect = crc16Ccitt(m + frame.dropLast(2))
+      let got = (UInt16(frame[frame.count - 2]) << 8) | UInt16(frame[frame.count - 1])
+      return expect == got
+    }
+
+    func feed(_ payload: Data) {
+      var off = 0
+      let inc = payload
+      while off < inc.count || (buf.count >= 2 && !complete) {
+        if buf.count < 2 {
+          let need = 2 - buf.count
+          let take = min(need, inc.count - off)
+          if take <= 0 { break }
+          buf.append(inc.subdata(in: off..<(off + take)))
+          off += take
+          if buf.count < 2 { break }
+        }
+        let flen = (Int(buf[0]) << 8) | Int(buf[1])
+        if flen == 0 {
+          complete = true
+          buf.removeAll()
+          return
+        }
+        let missing = flen - buf.count
+        if missing > 0 {
+          let take = min(missing, inc.count - off)
+          if take <= 0 { break }
+          buf.append(inc.subdata(in: off..<(off + take)))
+          off += take
+          if buf.count < flen { continue }
+        }
+        let frame = buf.subdata(in: 0..<flen)
+        buf = buf.count > flen ? buf.subdata(in: flen..<buf.count) : Data()
+        guard crcValid(frame) else { continue }
+        if flen >= 4 {
+          merged.append(frame.subdata(in: 2..<(flen - 2)))
+        }
+      }
+    }
+
+    for raw in chunks {
+      if raw.count >= 2, raw[0] == notifyConfiguration {
+        feed(raw.subdata(in: 1..<raw.count))
+      } else if raw.count >= 4 {
+        feed(raw)
+      }
+      if complete && !merged.isEmpty { break }
+    }
+    guard complete, !merged.isEmpty else {
+      throw TempivoSensorError(.unknown, "Incomplete config transfer.")
+    }
+    return merged
+  }
+}