@tempivo/sensor-beacon 0.2.0 → 0.3.2

package/android/src/main/java/expo/modules/tempivosensorbeacon/TempivoSensorBeaconModule.kt

@@ -0,0 +1,124 @@
+package expo.modules.tempivosensorbeacon
+
+import android.Manifest
+import android.content.Context
+import android.os.Build
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import com.tempivo.sensor.beacon.TempivoSensorException
+
+class TempivoSensorBeaconModule : Module() {
+  private val native = SensorBeaconNative()
+
+  override fun definition() = ModuleDefinition {
+    Name("TempivoSensorBeacon")
+    Events("onDeviceFound")
+
+    AsyncFunction("requestPermissions") { promise: Promise ->
+      val manager = appContext.permissions
+        ?: throw CodedException("runtimeUnavailable", "Permissions manager is not available.", null)
+      Permissions.askForPermissionsWithPermissionsManager(manager, promise, *blePermissions())
+    }
+
+    AsyncFunction("startScan") {
+      try {
+        native.startScan(requireContext()) { payload ->
+          sendEvent("onDeviceFound", payload)
+        }
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    Function("stopScan") {
+      native.stopScan()
+    }
+
+    Function("isScanning") {
+      native.isScanning
+    }
+
+    AsyncFunction("connect") { qrJson: String ->
+      try {
+        native.connect(requireContext(), qrJson)
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("disconnect") {
+      try {
+        native.disconnect()
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("getConfigurationJson") {
+      try {
+        native.configurationJson
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("setConfigurationJson") { json: String ->
+      try {
+        native.setConfigurationJson(json)
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("triggerTransmission") {
+      try {
+        native.triggerTransmission()
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("getCalibration") {
+      try {
+        native.calibration
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    OnDestroy {
+      native.stopScan()
+    }
+  }
+
+  private fun requireContext(): Context {
+    return appContext.reactContext
+      ?: appContext.currentActivity
+      ?: throw CodedException("runtimeUnavailable", "Android context is not available.", null)
+  }
+
+  private fun blePermissions(): Array<String> {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      arrayOf(Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT)
+    } else {
+      arrayOf(
+        Manifest.permission.ACCESS_FINE_LOCATION,
+        Manifest.permission.BLUETOOTH,
+        Manifest.permission.BLUETOOTH_ADMIN,
+      )
+    }
+  }
+}
+
+private fun Throwable.toSensorException(): CodedException {
+  if (this is CodedException) return this
+  val native = this as? SensorBeaconNative.NativeError ?: cause as? SensorBeaconNative.NativeError
+  if (native != null) {
+    return CodedException(native.code, native.message, null)
+  }
+  val clean = TempivoSensorException.sanitizeClientMessage(message)
+  return CodedException("unknown", clean.ifEmpty { "Sensor request failed." }, null)
+}

package/android-aar/build.gradle

@@ -0,0 +1,4 @@
+plugins {
+    id "com.android.library" version "8.7.3" apply false
+    id "org.jetbrains.kotlin.android" version "2.2.21" apply false
+}

package/{android → android-aar}/library/src/main/java/com/tempivo/sensor/beacon/PartnerBleRules.kt

@@ -93,9 +93,12 @@ internal object PartnerBleRules {
         return rules to calendars
     }
 
-    fun decompile(cfg: SensorConfiguration): TempivoSensorConfiguration {
+    fun decompile(cfg: SensorConfiguration): TempivoSensorConfiguration =
+        decompile(cfg.rules.orEmpty(), cfg.ruleCalendars)
+
+    fun decompile(rules: List<Rule>, calendars: List<RuleCalendar>? = null): TempivoSensorConfiguration {
         val padded = MutableList(12) { i ->
-            cfg.rules.orEmpty().getOrNull(i)
+            rules.getOrNull(i)
                 ?: Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION)
         }
         val orRefs = orSelectedPairs(padded)
@@ -164,7 +167,7 @@ internal object PartnerBleRules {
             }
         }
 
-        return TempivoSensorConfiguration(alerts, decompileSchedule(cfg.ruleCalendars))
+        return TempivoSensorConfiguration(alerts, decompileSchedule(calendars))
     }
 
     private fun orSelectedPairs(rules: List<Rule>): List<Pair<Int, Int>> {

package/{android → android-aar}/library/src/main/java/com/tempivo/sensor/beacon/SensorBleRuntime.kt

@@ -2,12 +2,14 @@ package com.tempivo.sensor.beacon
 
 import android.app.Application
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.withTimeout
 import pl.efento.mobile.bluetooth.EfentoBluetooth
 import pl.efento.mobile.bluetooth.api.SensorConnection
 import pl.efento.mobile.bluetooth.api.SensorLegacyConnection
 import pl.efento.mobile.bluetooth.exception.InvalidResetCodeException
 import pl.efento.mobile.bluetooth.exception.UnsupportedCommandException
 import pl.efento.mobile.bluetooth.model.BluetoothMacAddress
+import pl.efento.mobile.bluetooth.model.sensor.DisabledCondition
 import pl.efento.mobile.bluetooth.model.sensor.Rule
 import pl.efento.mobile.bluetooth.model.sensor.RuleCalendar
 import pl.efento.mobile.bluetooth.model.sensor.SensorConfiguration
@@ -31,15 +33,26 @@ internal object SensorBleRuntime {
     fun mapError(e: Throwable): TempivoSensorException {
         if (e is TempivoSensorException) return e
         val className = e.javaClass.name
+        val detail = clientSafeDetail(e.message)
         return when {
             e is InvalidResetCodeException || className.contains("InvalidResetCode") ->
-                TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "Invalid PIN.", e)
+                TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "Invalid PIN.")
             e is UnsupportedCommandException || className.contains("UnsupportedCommand") ->
-                TempivoSensorException(TempivoSensorException.Code.UNSUPPORTED_COMMAND, "Unsupported command.", e)
+                TempivoSensorException(TempivoSensorException.Code.UNSUPPORTED_COMMAND, "Unsupported command.")
             className.contains("NotConnected") ->
-                TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.", e)
+                TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.")
+            className.contains("Connect", ignoreCase = true) ||
+                detail.contains("connect", ignoreCase = true) ||
+                detail.contains("timeout", ignoreCase = true) ->
+                TempivoSensorException(
+                    TempivoSensorException.Code.CONNECT_FAILED,
+                    if (detail.isNotEmpty()) "Could not connect. $detail" else "Could not connect.",
+                )
             else ->
-                TempivoSensorException(TempivoSensorException.Code.UNKNOWN, "Sensor request failed.", e)
+                TempivoSensorException(
+                    TempivoSensorException.Code.UNKNOWN,
+                    if (detail.isNotEmpty()) "Sensor request failed. $detail" else "Sensor request failed.",
+                )
         }
     }
 
@@ -49,32 +62,57 @@ internal object SensorBleRuntime {
         bluetoothMac: String,
         pin: Int,
         legacy: Boolean,
+        deviceId: String = serial,
+        encryptionKey: String = "",
     ): Session {
         initialize(application)
         val mac = BluetoothMacAddress(bluetoothMac)
-        // PIN stays on the connection: set, trigger, calibration writes, and many other commands check it.
-        return if (legacy) {
-            val c =
-                EfentoBluetooth.sensorLegacyConnection(
-                    deviceID = serial,
-                    bluetoothMacAddress = mac,
-                    resetCode = pin,
-                    encryptionKey = "",
-                )
-            c.connect()
-            if (pin >= 0) c.resetCode = pin
-            Session.Legacy(c)
-        } else {
-            val c =
-                EfentoBluetooth.sensorConnection(
-                    deviceID = serial,
-                    bluetoothMacAddress = mac,
-                    resetCode = pin,
-                    encryptionKey = "",
-                )
-            c.connect()
-            if (pin >= 0) c.resetCode = pin
-            Session.Modern(c)
+        val id = deviceId.ifBlank { serial }
+        suspend fun open(useLegacy: Boolean): Session {
+            return if (useLegacy) {
+                val c =
+                    EfentoBluetooth.sensorLegacyConnection(
+                        deviceID = id,
+                        bluetoothMacAddress = mac,
+                        resetCode = pin,
+                        encryptionKey = encryptionKey,
+                    )
+                c.connect()
+                if (pin >= 0) c.resetCode = pin
+                if (encryptionKey.isNotEmpty()) c.encryptionKey = encryptionKey
+                Session.Legacy(c)
+            } else {
+                val c =
+                    EfentoBluetooth.sensorConnection(
+                        deviceID = id,
+                        bluetoothMacAddress = mac,
+                        resetCode = pin,
+                        encryptionKey = encryptionKey,
+                    )
+                c.connect()
+                if (pin >= 0) c.resetCode = pin
+                if (encryptionKey.isNotEmpty()) c.encryptionKey = encryptionKey
+                Session.Modern(c)
+            }
+        }
+        return try {
+            open(legacy)
+        } catch (first: Throwable) {
+            val mapped = mapError(first)
+            if (mapped.code == TempivoSensorException.Code.INVALID_PIN) throw mapped
+            try {
+                open(!legacy)
+            } catch (second: Throwable) {
+                val mappedSecond = mapError(second)
+                if (mappedSecond.code == TempivoSensorException.Code.UNKNOWN) {
+                    throw TempivoSensorException(
+                        TempivoSensorException.Code.CONNECT_FAILED,
+                        mapped.message + " Then " + mappedSecond.message,
+                        second,
+                    )
+                }
+                throw mappedSecond
+            }
         }
     }
 
@@ -86,14 +124,11 @@ internal object SensorBleRuntime {
         }
     }
 
-    suspend fun readConfiguration(session: Session): SensorConfiguration {
+    suspend fun readPartnerConfiguration(session: Session): TempivoSensorConfiguration {
         return when (session) {
-            is Session.Modern -> modernGetConfiguration(session.connection)
+            is Session.Modern -> PartnerBleRules.decompile(modernGetConfiguration(session.connection))
             is Session.Legacy ->
-                throw TempivoSensorException(
-                    TempivoSensorException.Code.UNSUPPORTED_COMMAND,
-                    "Configuration rules require a current-generation sensor session.",
-                )
+                PartnerBleRules.decompile(session.connection.commands.getRules { }, emptyList())
         }
     }
 
@@ -104,11 +139,19 @@ internal object SensorBleRuntime {
                 val next = base.copy(rules = rules.take(12), ruleCalendars = calendars.take(6))
                 session.connection.commands.setConfiguration(next) { }
             }
-            is Session.Legacy ->
-                throw TempivoSensorException(
-                    TempivoSensorException.Code.UNSUPPORTED_COMMAND,
-                    "Configuration rules require a current-generation sensor session.",
-                )
+            is Session.Legacy -> writeLegacyRules(session.connection, rules)
+        }
+    }
+
+    private suspend fun writeLegacyRules(legacy: SensorLegacyConnection, rules: List<Rule>) {
+        val cmd = legacy.commands
+        val current = runCatching { cmd.getRules { } }.getOrNull().orEmpty()
+        val currentActive =
+            current.filter { it.condition !is DisabledCondition }.map { it.id }.toSet()
+        for (rule in rules.take(12)) {
+            val disabled = rule.condition is DisabledCondition
+            if (disabled && rule.id !in currentActive) continue
+            withTimeout(20_000) { cmd.setRule(rule) { } }
         }
     }
 

package/{android → android-aar}/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorBeaconDecoder.kt

@@ -62,6 +62,20 @@ object TempivoSensorBeaconDecoder {
             0x22 to MeasureSpec("Current", 0.01, 1, true),
         )
 
+    /** FW 7+ → modern (`false`); FW 6.x / 5.x → legacy (`true`). */
+    fun legacyHintFromFirmware(firmware: String?): Boolean? {
+        val t = firmware?.trim().orEmpty()
+        if (t.isEmpty()) return null
+        if (t.startsWith("FW 5", ignoreCase = true) || t.startsWith("FW5", ignoreCase = true)) return true
+        val m = Regex("^(\\d+)\\.\\d+").find(t) ?: return null
+        val major = m.groupValues[1].toIntOrNull() ?: return null
+        return when {
+            major >= 7 -> false
+            major >= 1 -> true
+            else -> null
+        }
+    }
+
     /** 12-hex serial from FW6 `0x03` bytes 1–6 (same as BLE MAC on supported firmware). */
     fun serialKeyFromAdv03(frame: ByteArray): String? {
         if (frame.size < 7 || (frame[0].toInt() and 0xFF) != 0x03) return null

package/{android → android-aar}/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorBeaconScanner.kt

@@ -28,8 +28,17 @@ class TempivoSensorBeaconScanner(
     class ScanNotPermittedException(message: String) : Exception(message)
 
     private val appContext = context.applicationContext
+    data class SeenDevice(
+        val deviceId: String,
+        val bluetoothMac: String,
+        val serial: String,
+        val firmware: String?,
+        val encryptionEnabled: Boolean?,
+    )
+
     private val advLast03 = ConcurrentHashMap<String, ByteArray>()
     private val advLast04 = ConcurrentHashMap<String, ByteArray>()
+    private val lastSeen = ConcurrentHashMap<String, SeenDevice>()
     private var listener: Listener? = null
     private var scanning = false
 
@@ -50,6 +59,12 @@ class TempivoSensorBeaconScanner(
     fun clearCache() {
         advLast03.clear()
         advLast04.clear()
+        lastSeen.clear()
+    }
+
+    fun lookup(serial: String): SeenDevice? {
+        val key = TempivoSensorBeaconDecoder.macKey(serial)
+        return lastSeen[key]
     }
 
     fun startScan(listener: Listener) {
@@ -107,25 +122,39 @@ class TempivoSensorBeaconScanner(
 
     private fun buildDevice(result: ScanResult, key: String): TempivoSensorBeaconDevice? {
         val addr = result.device?.address ?: return null
-        val serial = key.uppercase(Locale.US)
-        val macColons = macWithColonsFromKey(serial)
+        val frame = advLast03[key]
+        val advSerial = frame?.let { TempivoSensorBeaconDecoder.serialKeyFromAdv03(it) }
+        val serial = (advSerial ?: key).uppercase(Locale.US)
+        val macColons = macWithColonsFromKey(if (key.length == 12) key else serial)
         val telemetry =
             TempivoSensorBeaconDecoder.buildTelemetry(
-                TempivoSensorBeaconDecoder.lookupKeys(serial),
+                TempivoSensorBeaconDecoder.lookupKeys(key, advSerial),
                 advLast03,
                 advLast04,
             )
         val summary =
             telemetry?.summary?.takeIf { it.isNotEmpty() }
                 ?: serial
-        return TempivoSensorBeaconDevice(
-            deviceId = addr,
-            bluetoothMacAddress = macColons,
-            serialNumber = serial,
-            rssi = result.rssi,
-            telemetry = telemetry,
-            summary = summary,
-        )
+        val device =
+            TempivoSensorBeaconDevice(
+                deviceId = addr,
+                bluetoothMacAddress = macColons,
+                serialNumber = serial,
+                rssi = result.rssi,
+                telemetry = telemetry,
+                summary = summary,
+            )
+        val seen =
+            SeenDevice(
+                deviceId = addr,
+                bluetoothMac = macColons,
+                serial = serial,
+                firmware = telemetry?.firmware,
+                encryptionEnabled = telemetry?.encryptionEnabled,
+            )
+        lastSeen[serial] = seen
+        lastSeen[key.uppercase(Locale.US)] = seen
+        return device
     }
 
     private fun bluetoothLeScanner() =

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

@@ -0,0 +1,35 @@
+package com.tempivo.sensor.beacon
+
+internal fun clientSafeDetail(raw: String?): String {
+    if (raw.isNullOrBlank()) return ""
+    return raw
+        .replace(VENDOR_PKG.toRegex(), "")
+        .replace(VENDOR_WORD.toRegex(), "")
+        .replace(Regex("\\s+"), " ")
+        .trim(' ', ':', '-', '.', '\n', '\t', '/')
+}
+
+private const val VENDOR_PKG = """(?i)pl\.[A-Za-z][A-Za-z0-9_.$]*"""
+private const val VENDOR_WORD = """(?i)\befento[A-Za-z0-9_$]*"""
+
+class TempivoSensorException(
+    val code: Code,
+    message: String,
+    cause: Throwable? = null,
+) : Exception(message, cause) {
+    companion object {
+        @JvmStatic
+        fun sanitizeClientMessage(raw: String?): String = clientSafeDetail(raw)
+    }
+
+    enum class Code {
+        INVALID_PIN,
+        INVALID_QR,
+        INVALID_CONFIG,
+        NOT_CONNECTED,
+        UNSUPPORTED_COMMAND,
+        RUNTIME_UNAVAILABLE,
+        CONNECT_FAILED,
+        UNKNOWN,
+    }
+}

package/{android → android-aar}/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorQr.kt

@@ -40,6 +40,15 @@ object TempivoSensorQrParser {
         }
     }
 
+    fun resolveSessionType(model: String?, firmware: String?): TempivoSensorSession.SessionType {
+        val hint = TempivoSensorBeaconDecoder.legacyHintFromFirmware(firmware)
+        return when (hint) {
+            true -> TempivoSensorSession.SessionType.LEGACY
+            false -> TempivoSensorSession.SessionType.MODERN
+            null -> sessionTypeFromModel(model)
+        }
+    }
+
     fun parse(json: String): TempivoSensorQr {
         val rec =
             try {

package/{android → android-aar}/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorSession.kt

@@ -3,6 +3,7 @@ package com.tempivo.sensor.beacon
 import android.app.Application
 import android.content.Context
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
@@ -32,10 +33,17 @@ class TempivoSensorSession(
         bluetoothMac: String,
         pin: String,
         sessionType: SessionType = SessionType.MODERN,
+        deviceId: String? = null,
+        firmware: String? = null,
     ) {
         val pinInt =
             pin.trim().toIntOrNull()
                 ?: throw TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "PIN must be numeric.")
+        val resolved =
+            TempivoSensorQrParser.resolveSessionType(
+                if (sessionType == SessionType.LEGACY) "HC5" else "HC7",
+                firmware,
+            )
         try {
             mutex.withLock {
                 SensorBleRuntime.disconnect(session)
@@ -47,14 +55,20 @@ class TempivoSensorSession(
                             serial = TempivoSensorQrParser.normalizeSerial(serial),
                             bluetoothMac = bluetoothMac,
                             pin = pinInt,
-                            legacy = sessionType == SessionType.LEGACY,
+                            legacy = resolved == SessionType.LEGACY,
+                            deviceId = deviceId?.ifBlank { null } ?: serial,
+                            encryptionKey = pin.trim(),
                         )
                     }
             }
         } catch (e: Throwable) {
             throw SensorBleRuntime.mapError(e).let {
                 if (it.code == TempivoSensorException.Code.UNKNOWN) {
-                    TempivoSensorException(TempivoSensorException.Code.CONNECT_FAILED, "Could not connect.", e)
+                    TempivoSensorException(
+                        TempivoSensorException.Code.CONNECT_FAILED,
+                        it.message ?: "Could not connect.",
+                        e,
+                    )
                 } else {
                     it
                 }
@@ -62,8 +76,15 @@ class TempivoSensorSession(
         }
     }
 
-    suspend fun connect(qr: TempivoSensorQr) {
-        connect(qr.serial, qr.bluetoothMac, qr.pin, qr.sessionType)
+    suspend fun connect(qr: TempivoSensorQr, seen: TempivoSensorBeaconScanner.SeenDevice? = null) {
+        connect(
+            serial = qr.serial,
+            bluetoothMac = seen?.bluetoothMac ?: qr.bluetoothMac,
+            pin = qr.pin,
+            sessionType = qr.sessionType,
+            deviceId = seen?.deviceId,
+            firmware = seen?.firmware,
+        )
     }
 
     suspend fun disconnect() {
@@ -74,9 +95,7 @@ class TempivoSensorSession(
     }
 
     suspend fun getConfiguration(): TempivoSensorConfiguration {
-        return runGatt {
-            SensorBleRuntime.decompile(SensorBleRuntime.readConfiguration(requireSession()))
-        }
+        return runGatt { SensorBleRuntime.readPartnerConfiguration(requireSession()) }
     }
 
     suspend fun getConfigurationJson(): String = TempivoSensorProfile.toJson(getConfiguration())
@@ -100,6 +119,20 @@ class TempivoSensorSession(
         return runGatt { SensorBleRuntime.readCalibration(requireSession()) }
     }
 
+    @JvmOverloads
+    fun connectBlocking(qr: TempivoSensorQr, seen: TempivoSensorBeaconScanner.SeenDevice? = null) =
+        runBlocking { connect(qr, seen) }
+
+    fun disconnectBlocking() = runBlocking { disconnect() }
+
+    fun getConfigurationJsonBlocking(): String = runBlocking { getConfigurationJson() }
+
+    fun setConfigurationJsonBlocking(json: String) = runBlocking { setConfigurationJson(json) }
+
+    fun triggerTransmissionBlocking(): TriggerResult = runBlocking { triggerTransmission() }
+
+    fun getCalibrationBlocking(): TempivoSensorCalibration = runBlocking { getCalibration() }
+
     private fun requireSession(): SensorBleRuntime.Session =
         session
             ?: throw TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.")