@tempivo/sensor-beacon 0.2.0 → 0.3.2

package/ios/Sources/TempivoSensorBeacon/TempivoSensorSession.swift

@@ -15,10 +15,19 @@ public final class TempivoSensorSession: @unchecked Sendable {
 
     public init() {}
 
-    public func connect(serial: String, bluetoothMac: String, pin: String, sessionType: TempivoSensorSessionType = .modern) throws {
-        guard let pinInt = Int32(pin.trimmingCharacters(in: .whitespacesAndNewlines)) else {
+    public func connect(
+        serial: String,
+        bluetoothMac: String,
+        pin: String,
+        sessionType: TempivoSensorSessionType = .modern,
+        deviceId: String? = nil,
+        firmware: String? = nil
+    ) throws {
+        let trimmedPin = pin.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let pinInt = Int32(trimmedPin) else {
             throw TempivoSensorError(.invalidPin, "PIN must be numeric.")
         }
+        let resolved = TempivoSensorQrParser.sessionType(fromModel: sessionType == .legacy ? "HC5" : "HC7", firmware: firmware)
         #if canImport(TempivoSensorBridge)
         lock.lock()
         defer { lock.unlock() }
@@ -28,7 +37,9 @@ public final class TempivoSensorSession: @unchecked Sendable {
                 serial: TempivoSensorQrParser.normalizeSerial(serial),
                 bluetoothMac: bluetoothMac,
                 pin: pinInt,
-                legacy: sessionType == .legacy
+                legacy: resolved == .legacy,
+                deviceId: deviceId?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "",
+                encryptionKey: trimmedPin
             )
         )
         try throwIfBridgeError(result)
@@ -38,8 +49,22 @@ public final class TempivoSensorSession: @unchecked Sendable {
         #endif
     }
 
-    public func connect(qr: TempivoSensorQr) throws {
-        try connect(serial: qr.serial, bluetoothMac: qr.bluetoothMac, pin: qr.pin, sessionType: qr.sessionType)
+    public func connect(qr: TempivoSensorQr, seen: TempivoSensorSeenDevice? = nil) throws {
+        let deviceId = seen?.deviceId.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        if deviceId.isEmpty {
+            throw TempivoSensorError(
+                .connectFailed,
+                "Sensor not in last scan. Scan first, then connect."
+            )
+        }
+        try connect(
+            serial: qr.serial,
+            bluetoothMac: seen?.bluetoothMac ?? qr.bluetoothMac,
+            pin: qr.pin,
+            sessionType: qr.sessionType,
+            deviceId: deviceId,
+            firmware: seen?.firmware
+        )
     }
 
     public func disconnect() {
@@ -148,14 +173,17 @@ public final class TempivoSensorSession: @unchecked Sendable {
 
     private func throwIfBridgeError(_ result: [String: Any]) throws {
         guard let code = intValue(result["errorCode"]), code != 0 else { return }
+        let detail = TempivoSensorError.sanitizeClientMessage(
+            (result["message"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        )
         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.")
+        case 5: throw TempivoSensorError(.connectFailed, detail.isEmpty ? "Could not connect." : "Could not connect. \(detail)")
+        case 6: throw TempivoSensorError(.invalidConfig, detail.isEmpty ? "Invalid configuration." : detail)
+        default: throw TempivoSensorError(.unknown, detail.isEmpty ? "Sensor request failed." : "Sensor request failed. \(detail)")
         }
     }
 }

package/ios/TempivoSensorBeacon.podspec

@@ -0,0 +1,35 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'TempivoSensorBeacon'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author'] || 'Tempivo'
+  s.homepage       = package['homepage']
+  s.platforms      = { :ios => '15.1' }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/tempivo/tempivo-app.git' }
+  s.static_framework = true
+  s.dependency 'ExpoModulesCore'
+  s.frameworks     = 'CoreBluetooth'
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule',
+    'EXCLUDED_ARCHS[sdk=iphonesimulator*]' => 'x86_64'
+  }
+  s.user_target_xcconfig = {
+    'EXCLUDED_ARCHS[sdk=iphonesimulator*]' => 'x86_64'
+  }
+
+  s.source_files = 'TempivoSensorBeaconModule.swift', 'Sources/TempivoSensorBeacon/**/*.swift'
+
+  bridge = File.join(__dir__, 'Frameworks/TempivoSensorBridge.xcframework')
+  if File.directory?(bridge)
+    s.vendored_frameworks = 'Frameworks/TempivoSensorBridge.xcframework'
+  end
+end

package/ios/TempivoSensorBeaconModule.swift

@@ -0,0 +1,217 @@
+import CoreBluetooth
+import ExpoModulesCore
+
+public class TempivoSensorBeaconModule: Module, TempivoSensorBeaconScannerDelegate {
+  private var scanner: TempivoSensorBeaconScanner?
+  private let session = TempivoSensorSession()
+
+  public func definition() -> ModuleDefinition {
+    Name("TempivoSensorBeacon")
+    Events("onDeviceFound")
+
+    AsyncFunction("requestPermissions") { () -> [String: Any] in
+      _ = self.requireScanner()
+      return self.permissionPayload()
+    }
+
+    AsyncFunction("startScan") {
+      self.requireScanner().startScanning()
+    }
+
+    Function("stopScan") {
+      self.scanner?.stopScanning()
+    }
+
+    Function("isScanning") { () -> Bool in
+      self.scanner?.scanning ?? false
+    }
+
+    AsyncFunction("connect") { (qrJson: String) -> [String: Any] in
+      do {
+        self.scanner?.stopScanning()
+        if !Thread.isMainThread {
+          Thread.sleep(forTimeInterval: 0.2)
+        }
+        let qr = try TempivoSensorQrParser.parse(qrJson)
+        let seen = self.scanner?.lookup(serial: qr.serial)
+        try self.session.connect(qr: qr, seen: seen)
+        return self.qrPayload(qr)
+      } catch {
+        throw self.mapError(error)
+      }
+    }
+
+    AsyncFunction("disconnect") {
+      self.session.disconnect()
+    }
+
+    AsyncFunction("getConfigurationJson") { () -> String in
+      do {
+        return try self.session.getConfigurationJson()
+      } catch {
+        throw self.mapError(error)
+      }
+    }
+
+    AsyncFunction("setConfigurationJson") { (json: String) in
+      do {
+        try self.session.setConfigurationJson(json)
+      } catch {
+        throw self.mapError(error)
+      }
+    }
+
+    AsyncFunction("triggerTransmission") { () -> [String: Any] in
+      do {
+        let result = try self.session.triggerTransmission()
+        return ["ok": result.ok, "supported": result.supported]
+      } catch {
+        throw self.mapError(error)
+      }
+    }
+
+    AsyncFunction("getCalibration") { () -> [String: Any] in
+      do {
+        let cal = try self.session.getCalibration()
+        var payload: [String: Any] = [:]
+        if let date = cal.laboratoryCalibrationDate {
+          payload["laboratoryCalibrationDate"] = date
+        }
+        if let ts = cal.laboratoryCalibrationTimestamp {
+          payload["laboratoryCalibrationTimestamp"] = Int(ts)
+        }
+        return payload
+      } catch {
+        throw self.mapError(error)
+      }
+    }
+
+    OnDestroy {
+      self.scanner?.stopScanning()
+      self.session.disconnect()
+    }
+  }
+
+  public func sensorBeaconScanner(
+    _ scanner: TempivoSensorBeaconScanner,
+    didDiscover discovery: SensorBeaconDiscovery
+  ) {
+    sendEvent("onDeviceFound", devicePayload(discovery))
+  }
+
+  private func requireScanner() -> TempivoSensorBeaconScanner {
+    if let scanner {
+      return scanner
+    }
+    let created = TempivoSensorBeaconScanner()
+    created.delegate = self
+    scanner = created
+    return created
+  }
+
+  private func permissionPayload() -> [String: Any] {
+    if #available(iOS 13.1, *) {
+      let status = CBManager.authorization
+      let granted = status == .allowedAlways
+      let statusName: String
+      switch status {
+      case .allowedAlways: statusName = "granted"
+      case .notDetermined: statusName = "undetermined"
+      default: statusName = "denied"
+      }
+      return [
+        "granted": granted,
+        "status": statusName,
+        "canAskAgain": status == .notDetermined,
+        "expires": "never",
+      ]
+    }
+    return [
+      "granted": true,
+      "status": "granted",
+      "canAskAgain": true,
+      "expires": "never",
+    ]
+  }
+
+  private func qrPayload(_ qr: TempivoSensorQr) -> [String: Any] {
+    var payload: [String: Any] = [
+      "serial": qr.serial,
+      "pin": qr.pin,
+      "sessionType": qr.sessionType.rawValue,
+      "bluetoothMac": qr.bluetoothMac,
+    ]
+    if let model = qr.model {
+      payload["model"] = model
+    }
+    return payload
+  }
+
+  private func devicePayload(_ discovery: SensorBeaconDiscovery) -> [String: Any] {
+    var payload: [String: Any] = [
+      "deviceId": discovery.deviceId,
+      "rssi": discovery.rssi,
+    ]
+    if let serial = discovery.serialNumber {
+      payload["serialNumber"] = serial
+    }
+    if let mac = discovery.bluetoothMacAddress {
+      payload["bluetoothMacAddress"] = mac
+    }
+    if let reading = discovery.reading {
+      payload["summary"] = reading.summary
+      payload["telemetry"] = telemetryPayload(reading)
+    }
+    return payload
+  }
+
+  private func telemetryPayload(_ reading: SensorBeaconReading) -> [String: Any] {
+    var payload: [String: Any] = [
+      "readingsCount": reading.readingsCount,
+      "summary": reading.summary,
+      "readings": reading.readings.map { slot in
+        [
+          "typeHex": slot.typeHex,
+          "raw24": slot.raw24,
+          "text": slot.text,
+        ] as [String: Any]
+      },
+    ]
+    if let firmware = reading.firmware { payload["firmware"] = firmware }
+    if let batteryOk = reading.batteryOk { payload["batteryOk"] = batteryOk }
+    if let encryptionEnabled = reading.encryptionEnabled { payload["encryptionEnabled"] = encryptionEnabled }
+    if let cellularStatus = reading.cellularStatus { payload["cellularStatus"] = cellularStatus }
+    if let measurementCounter = reading.measurementCounter { payload["measurementCounter"] = measurementCounter }
+    if let readingTimestampUnix = reading.readingTimestampUnix { payload["readingTimestampUnix"] = readingTimestampUnix }
+    if let readingTimestampIso = reading.readingTimestampIso { payload["readingTimestampIso"] = readingTimestampIso }
+    if let measurementIntervalSeconds = reading.measurementIntervalSeconds {
+      payload["measurementIntervalSeconds"] = measurementIntervalSeconds
+    }
+    return payload
+  }
+
+  private func mapError(_ error: Error) -> SensorBeaconException {
+    if let sensor = error as? TempivoSensorError {
+      return SensorBeaconException(code: sensor.code.rawValue, reason: sensor.message)
+    }
+    let reason = TempivoSensorError.sanitizeClientMessage(error.localizedDescription)
+    return SensorBeaconException(
+      code: "unknown",
+      reason: reason.isEmpty ? "Sensor request failed." : reason
+    )
+  }
+}
+
+internal final class SensorBeaconException: Exception {
+  private let customCode: String
+  private let customReason: String
+
+  init(code: String, reason: String) {
+    self.customCode = code
+    self.customReason = reason
+    super.init()
+  }
+
+  override var code: String { customCode }
+  override var reason: String { customReason }
+}

package/package.json

@@ -1,20 +1,38 @@
 {
   "name": "@tempivo/sensor-beacon",
-  "version": "0.2.0",
-  "description": "Tempivo sensor BLE SDK: advertisement decode plus GATT session (config rules, transmission trigger, lab calibration date).",
+  "version": "0.3.2",
+  "description": "Tempivo sensor BLE SDK for Expo, React Native, Android, iOS, and Node.",
   "homepage": "https://app.tempivo.com/integrations",
+  "author": "Tempivo",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "react-native": "./dist/react-native.js",
   "exports": {
     ".": {
+      "react-native": {
+        "types": "./dist/react-native.d.ts",
+        "default": "./dist/react-native.js"
+      },
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./react-native": {
+      "types": "./dist/react-native.d.ts",
+      "default": "./dist/react-native.js"
+    },
+    "./app.plugin": "./app.plugin.cjs",
+    "./app.plugin.js": "./app.plugin.cjs",
+    "./app.plugin.cjs": "./app.plugin.cjs",
+    "./package.json": "./package.json"
   },
   "files": [
+    "app.plugin.cjs",
     "dist",
     "android",
+    "android-aar",
+    "expo-module.config.json",
     "ios",
     "LICENSE",
     "README.md"
@@ -29,7 +47,8 @@
     "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:ios-bridge": "bash scripts/build-ios-bridge.sh && node scripts/copy-ios-bridge.mjs",
+    "copy:ios-bridge": "node scripts/copy-ios-bridge.mjs",
     "build:all": "npm run build:ts && npm run build:android",
     "prepare": "npm run build:ts",
     "test": "npm run test:all",
@@ -37,7 +56,7 @@
     "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"
+    "prepublishOnly": "npm run build:all && npm run copy:ios-bridge"
   },
   "keywords": [
     "tempivo",
@@ -48,9 +67,31 @@
     "sensor",
     "manufacturer-data",
     "android",
-    "ios"
+    "ios",
+    "expo",
+    "react-native"
   ],
   "license": "MIT",
+  "peerDependencies": {
+    "expo": "*",
+    "expo-modules-core": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "peerDependenciesMeta": {
+    "expo": {
+      "optional": true
+    },
+    "expo-modules-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "jest": "^29.7.0",

package/android/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorError.kt

@@ -1,18 +0,0 @@
-package com.tempivo.sensor.beacon
-
-class TempivoSensorException(
-    val code: Code,
-    message: String,
-    cause: Throwable? = null,
-) : Exception(message, cause) {
-    enum class Code {
-        INVALID_PIN,
-        INVALID_QR,
-        INVALID_CONFIG,
-        NOT_CONNECTED,
-        UNSUPPORTED_COMMAND,
-        RUNTIME_UNAVAILABLE,
-        CONNECT_FAILED,
-        UNKNOWN,
-    }
-}