@tempivo/sensor-beacon 0.1.0 → 0.2.0

package/ios/Sources/TempivoSensorBeacon/TempivoSensorError.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+public enum TempivoSensorErrorCode: String, Sendable {
+    case invalidPin
+    case invalidQr
+    case invalidConfig
+    case notConnected
+    case unsupportedCommand
+    case runtimeUnavailable
+    case connectFailed
+    case unknown
+}
+
+public struct TempivoSensorError: Error, LocalizedError, Sendable {
+    public let code: TempivoSensorErrorCode
+    public let message: String
+
+    public init(_ code: TempivoSensorErrorCode, _ message: String) {
+        self.code = code
+        self.message = message
+    }
+
+    public var errorDescription: String? { message }
+}

package/ios/Sources/TempivoSensorBeacon/TempivoSensorProfile.swift

@@ -0,0 +1,123 @@
+import Foundation
+
+public enum TempivoSensorProfile {
+    public static func parse(json: String) throws -> TempivoSensorConfiguration {
+        guard let data = json.data(using: .utf8),
+              let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            throw TempivoSensorError(.invalidConfig, "Configuration is not valid JSON.")
+        }
+        return try parse(obj)
+    }
+
+    public static func parse(_ obj: [String: Any]) throws -> TempivoSensorConfiguration {
+        if obj["profiles"] is [Any] {
+            throw TempivoSensorError(.invalidConfig, "Pass one profile from GET /devices/config-profiles/{slug}, not the list.")
+        }
+        let body: [String: Any]
+        if let nested = obj["profile"] as? [String: Any],
+           nested["temperatureAlerts"] != nil || nested["schedule"] != nil || nested["slug"] != nil {
+            body = nested
+        } else {
+            body = obj
+        }
+        if body["temperatureAlerts"] == nil && body["alarmRules"] != nil {
+            throw TempivoSensorError(.invalidConfig, "Use a config profile with temperatureAlerts (GET /devices/config-profiles/{slug}), not alarmRules.")
+        }
+        let rawAlerts = body["temperatureAlerts"] as? [Any] ?? []
+        let alerts = try rawAlerts.enumerated().map { try parseAlert($0.element, index: $0.offset) }
+        return TempivoSensorConfiguration(temperatureAlerts: alerts, schedule: try parseSchedule(body["schedule"] as? [String: Any]))
+    }
+
+    public static func jsonString(_ cfg: TempivoSensorConfiguration) throws -> String {
+        var alerts: [[String: Any]] = []
+        for a in cfg.temperatureAlerts {
+            var o: [String: Any] = [
+                "type": a.type,
+                "channel": a.channel.rawValue,
+                "transmitOnBreach": a.transmitOnBreach,
+            ]
+            if let v = a.lowC { o["lowC"] = v }
+            if let v = a.highC { o["highC"] = v }
+            if let v = a.minC { o["minC"] = v }
+            if let v = a.maxC { o["maxC"] = v }
+            if let v = a.hysteresisC { o["hysteresisC"] = v }
+            if a.type == "range" { o["transmitOnReturn"] = a.transmitOnReturn }
+            alerts.append(o)
+        }
+        var schedule: [String: Any]
+        if cfg.schedule.always {
+            schedule = ["always": true]
+        } else {
+            schedule = [
+                "weekdays": cfg.schedule.weekdays,
+                "from": cfg.schedule.from ?? "00:00",
+                "to": cfg.schedule.to ?? "23:59",
+                "utcOffsetMinutes": cfg.schedule.utcOffsetMinutes,
+            ]
+        }
+        let root: [String: Any] = ["temperatureAlerts": alerts, "schedule": schedule]
+        let data = try JSONSerialization.data(withJSONObject: root, options: [])
+        return String(data: data, encoding: .utf8) ?? "{}"
+    }
+
+    private static func parseAlert(_ raw: Any, index: Int) throws -> TempivoTemperatureAlert {
+        guard let item = raw as? [String: Any] else {
+            throw TempivoSensorError(.invalidConfig, "temperatureAlerts[\(index)] must be an object.")
+        }
+        guard let channelRaw = item["channel"] as? String,
+              let channel = TempivoTemperatureChannel(rawValue: channelRaw)
+        else {
+            throw TempivoSensorError(.invalidConfig, "temperatureAlerts[\(index)].channel must be ambient or probe.")
+        }
+        let hyst = number(item["hysteresisC"]) ?? 1
+        let transmit = (item["transmitOnBreach"] as? Bool) ?? true
+        let transmitOnReturn = (item["transmitOnReturn"] as? Bool) ?? true
+        switch item["type"] as? String {
+        case "range":
+            guard let low = number(item["lowC"]), let high = number(item["highC"]) else {
+                throw TempivoSensorError(.invalidConfig, "temperatureAlerts[\(index)] needs lowC and highC.")
+            }
+            guard high > low else {
+                throw TempivoSensorError(.invalidConfig, "temperatureAlerts[\(index)]: highC must be greater than lowC.")
+            }
+            return TempivoTemperatureAlert(type: "range", channel: channel, lowC: low, highC: high, hysteresisC: hyst, transmitOnBreach: transmit, transmitOnReturn: transmitOnReturn)
+        case "min":
+            guard let minC = number(item["minC"]) else {
+                throw TempivoSensorError(.invalidConfig, "temperatureAlerts[\(index)] needs minC.")
+            }
+            return TempivoTemperatureAlert(type: "min", channel: channel, minC: minC, hysteresisC: hyst, transmitOnBreach: transmit)
+        case "max":
+            guard let maxC = number(item["maxC"]) else {
+                throw TempivoSensorError(.invalidConfig, "temperatureAlerts[\(index)] needs maxC.")
+            }
+            return TempivoTemperatureAlert(type: "max", channel: channel, maxC: maxC, hysteresisC: hyst, transmitOnBreach: transmit)
+        default:
+            throw TempivoSensorError(.invalidConfig, "temperatureAlerts[\(index)].type must be range, min, or max.")
+        }
+    }
+
+    private static func parseSchedule(_ raw: [String: Any]?) throws -> TempivoSchedule {
+        guard let raw else { return .alwaysOn }
+        if raw["always"] as? Bool == true { return .alwaysOn }
+        guard let weekdays = raw["weekdays"] as? [Int], !weekdays.isEmpty, weekdays.allSatisfy({ (0...6).contains($0) }) else {
+            throw TempivoSensorError(.invalidConfig, "schedule.weekdays is required.")
+        }
+        guard let from = raw["from"] as? String, let to = raw["to"] as? String,
+              from.range(of: "^([01]\\d|2[0-3]):([0-5]\\d)$", options: .regularExpression) != nil,
+              to.range(of: "^([01]\\d|2[0-3]):([0-5]\\d)$", options: .regularExpression) != nil
+        else {
+            throw TempivoSensorError(.invalidConfig, "schedule.from and schedule.to must be HH:MM.")
+        }
+        guard let utc = raw["utcOffsetMinutes"] as? Int else {
+            throw TempivoSensorError(.invalidConfig, "schedule.utcOffsetMinutes is required.")
+        }
+        return TempivoSchedule(always: false, weekdays: weekdays, from: from, to: to, utcOffsetMinutes: utc)
+    }
+
+    private static func number(_ value: Any?) -> Double? {
+        if let d = value as? Double { return d }
+        if let n = value as? NSNumber { return n.doubleValue }
+        return nil
+    }
+}

package/ios/Sources/TempivoSensorBeacon/TempivoSensorQr.swift

@@ -0,0 +1,78 @@
+import Foundation
+
+public struct TempivoSensorQr: Sendable, Equatable {
+    public let serial: String
+    public let pin: String
+    public let model: String?
+    public let sessionType: TempivoSensorSessionType
+    public let bluetoothMac: String
+}
+
+public enum TempivoSensorQrParser {
+    public static func normalizeSerial(_ value: String) -> String {
+        value.trimmingCharacters(in: .whitespacesAndNewlines)
+            .uppercased()
+            .replacingOccurrences(of: "[^A-Z0-9]", with: "", options: .regularExpression)
+    }
+
+    public static func bluetoothMacFromSerial(_ serial: String) throws -> String {
+        let key = normalizeSerial(serial)
+        guard key.count == 12, key.range(of: "^[0-9A-F]{12}$", options: .regularExpression) != nil else {
+            throw TempivoSensorError(.invalidQr, "Serial must be 12 hex characters.")
+        }
+        return stride(from: 0, to: 12, by: 2).map { i in
+            let start = key.index(key.startIndex, offsetBy: i)
+            let end = key.index(start, offsetBy: 2)
+            return String(key[start..<end])
+        }.joined(separator: ":")
+    }
+
+    public static let defaultModel = "HC7"
+
+    public static func sessionType(fromModel model: String?) -> TempivoSensorSessionType {
+        guard let model, !model.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            return .modern
+        }
+        let m = model.trimmingCharacters(in: .whitespacesAndNewlines).uppercased().replacingOccurrences(of: "-", with: "")
+        if m == "HC5" || m.hasPrefix("6") { return .legacy }
+        return .modern
+    }
+
+    public static func parse(_ json: String) throws -> TempivoSensorQr {
+        guard let data = json.trimmingCharacters(in: .whitespacesAndNewlines).data(using: .utf8),
+              let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            throw TempivoSensorError(.invalidQr, "QR is not valid JSON.")
+        }
+        let snRaw: String = {
+            if let s = obj["sn"] as? String { return s }
+            if let n = obj["sn"] as? NSNumber { return n.stringValue }
+            return ""
+        }()
+        let serial = normalizeSerial(snRaw)
+        let pin = pinFrom(obj)
+        guard serial.count >= 8 else {
+            throw TempivoSensorError(.invalidQr, "QR is missing serial (sn).")
+        }
+        guard !pin.isEmpty else {
+            throw TempivoSensorError(.invalidQr, "QR is missing PIN.")
+        }
+        let rawModel = (obj["model"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        let model = rawModel.isEmpty ? defaultModel : rawModel
+        let hex = serial.count == 12 ? serial : String(serial.suffix(12))
+        return TempivoSensorQr(
+            serial: serial,
+            pin: pin,
+            model: model,
+            sessionType: sessionType(fromModel: model),
+            bluetoothMac: try bluetoothMacFromSerial(hex)
+        )
+    }
+
+    private static func pinFrom(_ obj: [String: Any]) -> String {
+        let raw = obj["pin"] ?? obj["resetCode"]
+        if let s = raw as? String { return s.trimmingCharacters(in: .whitespacesAndNewlines) }
+        if let n = raw as? NSNumber { return n.stringValue }
+        return ""
+    }
+}

package/ios/Sources/TempivoSensorBeacon/TempivoSensorSession.swift

@@ -0,0 +1,161 @@
+import Foundation
+
+#if canImport(TempivoSensorBridge)
+import TempivoSensorBridge
+#endif
+
+/// GATT session: connect, read/write alert rules and schedule, trigger uplink, read lab calibration date.
+public final class TempivoSensorSession: @unchecked Sendable {
+    private let lock = NSLock()
+    private var connected = false
+
+    #if canImport(TempivoSensorBridge)
+    private let bridge = TempivoSensorBridge()
+    #endif
+
+    public init() {}
+
+    public func connect(serial: String, bluetoothMac: String, pin: String, sessionType: TempivoSensorSessionType = .modern) throws {
+        guard let pinInt = Int32(pin.trimmingCharacters(in: .whitespacesAndNewlines)) else {
+            throw TempivoSensorError(.invalidPin, "PIN must be numeric.")
+        }
+        #if canImport(TempivoSensorBridge)
+        lock.lock()
+        defer { lock.unlock() }
+        bridge.initialize()
+        let result = parseBridgeJson(
+            bridge.connectPayloadJson(
+                serial: TempivoSensorQrParser.normalizeSerial(serial),
+                bluetoothMac: bluetoothMac,
+                pin: pinInt,
+                legacy: sessionType == .legacy
+            )
+        )
+        try throwIfBridgeError(result)
+        connected = true
+        #else
+        throw TempivoSensorError(.runtimeUnavailable, "Sensor GATT requires a physical device with the native runtime.")
+        #endif
+    }
+
+    public func connect(qr: TempivoSensorQr) throws {
+        try connect(serial: qr.serial, bluetoothMac: qr.bluetoothMac, pin: qr.pin, sessionType: qr.sessionType)
+    }
+
+    public func disconnect() {
+        #if canImport(TempivoSensorBridge)
+        lock.lock()
+        defer { lock.unlock() }
+        bridge.disconnect()
+        connected = false
+        #else
+        lock.lock()
+        connected = false
+        lock.unlock()
+        #endif
+    }
+
+    public func getConfiguration() throws -> TempivoSensorConfiguration {
+        try TempivoSensorProfile.parse(json: getConfigurationJson())
+    }
+
+    public func getConfigurationJson() throws -> String {
+        #if canImport(TempivoSensorBridge)
+        try requireConnected()
+        let result = parseBridgeJson(bridge.getConfigurationPayloadJson())
+        try throwIfBridgeError(result)
+        guard let json = result["configurationJson"] as? String else {
+            throw TempivoSensorError(.unknown, "Could not read configuration.")
+        }
+        return json
+        #else
+        throw TempivoSensorError(.runtimeUnavailable, "Sensor GATT requires a physical device with the native runtime.")
+        #endif
+    }
+
+    public func setConfiguration(_ configuration: TempivoSensorConfiguration) throws {
+        try setConfigurationJson(TempivoSensorProfile.jsonString(configuration))
+    }
+
+    public func setConfigurationJson(_ json: String) throws {
+        _ = try TempivoSensorProfile.parse(json: json)
+        #if canImport(TempivoSensorBridge)
+        try requireConnected()
+        let result = parseBridgeJson(bridge.setConfigurationPayloadJson(json: json))
+        try throwIfBridgeError(result)
+        #else
+        throw TempivoSensorError(.runtimeUnavailable, "Sensor GATT requires a physical device with the native runtime.")
+        #endif
+    }
+
+    public func triggerTransmission() throws -> TempivoTriggerTransmissionResult {
+        #if canImport(TempivoSensorBridge)
+        try requireConnected()
+        let result = parseBridgeJson(bridge.triggerTransmissionPayloadJson())
+        if let code = intValue(result["errorCode"]), code != 0 {
+            try throwIfBridgeError(result)
+        }
+        return TempivoTriggerTransmissionResult(
+            ok: (result["ok"] as? Bool) ?? false,
+            supported: (result["supported"] as? Bool) ?? false
+        )
+        #else
+        throw TempivoSensorError(.runtimeUnavailable, "Sensor GATT requires a physical device with the native runtime.")
+        #endif
+    }
+
+    public func getCalibration() throws -> TempivoSensorCalibration {
+        #if canImport(TempivoSensorBridge)
+        try requireConnected()
+        let result = parseBridgeJson(bridge.getCalibrationPayloadJson())
+        try throwIfBridgeError(result)
+        let ts = int64Value(result["laboratoryCalibrationTimestamp"])
+        return TempivoSensorCalibrationDecoder.decode(ts)
+        #else
+        throw TempivoSensorError(.runtimeUnavailable, "Sensor GATT requires a physical device with the native runtime.")
+        #endif
+    }
+
+    private func requireConnected() throws {
+        lock.lock()
+        let ok = connected
+        lock.unlock()
+        if !ok {
+            throw TempivoSensorError(.notConnected, "Not connected.")
+        }
+    }
+
+    private func parseBridgeJson(_ raw: String) -> [String: Any] {
+        guard let data = raw.data(using: .utf8),
+              let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return ["errorCode": 7]
+        }
+        return obj
+    }
+
+    private func intValue(_ raw: Any?) -> Int? {
+        if let i = raw as? Int { return i }
+        if let n = raw as? NSNumber { return n.intValue }
+        return nil
+    }
+
+    private func int64Value(_ raw: Any?) -> Int64? {
+        if let i = raw as? Int64 { return i }
+        if let n = raw as? NSNumber { return n.int64Value }
+        return nil
+    }
+
+    private func throwIfBridgeError(_ result: [String: Any]) throws {
+        guard let code = intValue(result["errorCode"]), code != 0 else { return }
+        switch code {
+        case 1: throw TempivoSensorError(.invalidPin, "Invalid PIN.")
+        case 2: throw TempivoSensorError(.notConnected, "Not connected.")
+        case 3: throw TempivoSensorError(.unsupportedCommand, "Unsupported command.")
+        case 4: throw TempivoSensorError(.runtimeUnavailable, "Sensor GATT is not available on this device.")
+        case 5: throw TempivoSensorError(.connectFailed, "Could not connect.")
+        case 6: throw TempivoSensorError(.invalidConfig, (result["message"] as? String) ?? "Invalid configuration.")
+        default: throw TempivoSensorError(.unknown, "Sensor request failed.")
+        }
+    }
+}

package/ios/Sources/TempivoSensorBeacon/TempivoSensorSessionTypes.swift

@@ -0,0 +1,93 @@
+import Foundation
+
+public enum TempivoSensorSessionType: String, Sendable {
+    case modern
+    case legacy
+}
+
+public enum TempivoTemperatureChannel: String, Sendable {
+    case ambient
+    case probe
+}
+
+public struct TempivoTemperatureAlert: Sendable, Equatable {
+    public var type: String
+    public var channel: TempivoTemperatureChannel
+    public var lowC: Double?
+    public var highC: Double?
+    public var minC: Double?
+    public var maxC: Double?
+    public var hysteresisC: Double?
+    public var transmitOnBreach: Bool
+    public var transmitOnReturn: Bool
+
+    public init(
+        type: String,
+        channel: TempivoTemperatureChannel,
+        lowC: Double? = nil,
+        highC: Double? = nil,
+        minC: Double? = nil,
+        maxC: Double? = nil,
+        hysteresisC: Double? = nil,
+        transmitOnBreach: Bool = true,
+        transmitOnReturn: Bool = true
+    ) {
+        self.type = type
+        self.channel = channel
+        self.lowC = lowC
+        self.highC = highC
+        self.minC = minC
+        self.maxC = maxC
+        self.hysteresisC = hysteresisC
+        self.transmitOnBreach = transmitOnBreach
+        self.transmitOnReturn = transmitOnReturn
+    }
+}
+
+public struct TempivoSchedule: Sendable, Equatable {
+    public var always: Bool
+    public var weekdays: [Int]
+    public var from: String?
+    public var to: String?
+    public var utcOffsetMinutes: Int
+
+    public static let alwaysOn = TempivoSchedule(always: true, weekdays: [], from: nil, to: nil, utcOffsetMinutes: 0)
+
+    public init(always: Bool, weekdays: [Int] = [], from: String? = nil, to: String? = nil, utcOffsetMinutes: Int = 0) {
+        self.always = always
+        self.weekdays = weekdays
+        self.from = from
+        self.to = to
+        self.utcOffsetMinutes = utcOffsetMinutes
+    }
+}
+
+public struct TempivoSensorConfiguration: Sendable, Equatable {
+    public var temperatureAlerts: [TempivoTemperatureAlert]
+    public var schedule: TempivoSchedule
+
+    public init(temperatureAlerts: [TempivoTemperatureAlert], schedule: TempivoSchedule) {
+        self.temperatureAlerts = temperatureAlerts
+        self.schedule = schedule
+    }
+}
+
+public struct TempivoSensorCalibration: Sendable, Equatable {
+    public var laboratoryCalibrationDate: String?
+    public var laboratoryCalibrationTimestamp: Int64?
+
+    public init(laboratoryCalibrationDate: String?, laboratoryCalibrationTimestamp: Int64?) {
+        self.laboratoryCalibrationDate = laboratoryCalibrationDate
+        self.laboratoryCalibrationTimestamp = laboratoryCalibrationTimestamp
+    }
+}
+
+public struct TempivoTriggerTransmissionResult: Sendable, Equatable {
+    public var ok: Bool
+    public var supported: Bool
+
+    public init(ok: Bool, supported: Bool) {
+        self.ok = ok
+        self.supported = supported
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tempivo/sensor-beacon",
-  "version": "0.1.0",
-  "description": "Decode Tempivo sensor BLE manufacturer advertisements (0x026C). Advertising only, no GATT connect. For integrators and custom apps.",
+  "version": "0.2.0",
+  "description": "Tempivo sensor BLE SDK: advertisement decode plus GATT session (config rules, transmission trigger, lab calibration date).",
   "homepage": "https://app.tempivo.com/integrations",
   "type": "module",
   "main": "dist/index.js",
@@ -14,6 +14,8 @@
   },
   "files": [
     "dist",
+    "android",
+    "ios",
     "LICENSE",
     "README.md"
   ],
@@ -24,17 +26,29 @@
     "node": ">=18"
   },
   "scripts": {
-    "build": "tsc",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config jest.config.mjs",
-    "prepublishOnly": "npm run build"
+    "build": "npm run build:ts",
+    "build:ts": "tsc",
+    "build:android": "node scripts/build-aar.mjs",
+    "build:ios-bridge": "bash scripts/build-ios-bridge.sh",
+    "build:all": "npm run build:ts && npm run build:android",
+    "prepare": "npm run build:ts",
+    "test": "npm run test:all",
+    "test:unit": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config jest.config.mjs",
+    "test:python": "PYTHONPATH=python python3 -m pytest python/tests -q",
+    "test:all": "npm run test:unit && npm run test:python",
+    "test:smoke": "node scripts/smoke-test.mjs",
+    "prepublishOnly": "npm run build:all"
   },
   "keywords": [
     "tempivo",
     "ble",
     "bluetooth",
     "beacon",
+    "gatt",
     "sensor",
-    "manufacturer-data"
+    "manufacturer-data",
+    "android",
+    "ios"
   ],
   "license": "MIT",
   "devDependencies": {