@tempivo/sensor-beacon 0.3.3 → 0.4.3

package/README.md

@@ -151,8 +151,8 @@ Sticker QR is JSON. Parse with `parseSensorQrJson`.
 |------|------|---------|
 | `serial` | string | Device serial, 12 hex chars, no colons. From QR `sn`. |
 | `pin` | string | Sticker PIN. Required on `connect`. Also accepted as QR `resetCode`. |
-| `model` | string | Optional. Firmware from the last scan wins when present. |
-| `sessionType` | `modern` \| `legacy` | GATT path. Firmware 7+ is `modern`. Firmware 6.x is `legacy`. |
+| `model` | string | Optional. Defaults to **HC7**. **HC5** is rejected. |
+| `sessionType` | `modern` | Always modern GATT (HC7 / firmware 7+). |
 | `bluetoothMac` | string | BLE MAC with colons, derived from `serial`. |
 
 ## Scan result
@@ -172,7 +172,7 @@ Filter manufacturer data on company id **0x026C**. Active scanning is on so scan
 
 | Field | Meaning |
 |------|---------|
-| `firmware` | `major.minor.patch`, e.g. `7.3.4`. Firmware 7+ is modern GATT. |
+| `firmware` | `major.minor.patch`, e.g. `7.3.4`. Partner GATT requires firmware 7+. |
 | `batteryOk` | Battery status flag. |
 | `encryptionEnabled` | Advertisement payload encryption flag. |
 | `cellularStatus` | `ble_only`, `cell_ok`, `no_server`, or `net_issue`. |
@@ -224,7 +224,7 @@ AAR after `npm run build:android` (from `packages/tempivo-sensor-beacon`):
 | `android/libs/tempivo-sensor-beacon.aar` | Expo / React Native autolinking (`android/build.gradle`) |
 | `dist/tempivo-sensor-beacon.aar` | Same file; handy for plain Android `files(...)` deps |
 
-Sources: `android-aar/library`. Request `BLUETOOTH_SCAN` and `BLUETOOTH_CONNECT` (API 31+) or location on older APIs.
+Sources: `android-aar/library`. Request `BLUETOOTH_SCAN`, `BLUETOOTH_CONNECT`, and on some OEMs **`ACCESS_FINE_LOCATION`** even on API 31+ (location on older APIs).
 
 **Scan:** temperature and other live values are in scan-response frame **`0x04`** (`telemetry.readings`). Frame **`0x03`** alone fills firmware / battery / cellular but leaves `readings` empty until an active scan delivers `0x04` (usually within a second or two). Keep scanning; do not stop on the first event.
 

package/android/build.gradle

@@ -4,14 +4,14 @@ plugins {
 }
 
 group = 'com.tempivo.sensor.beacon'
-version = '0.3.3'
+version = '0.4.3'
 
 android {
   namespace "expo.modules.tempivosensorbeacon"
   defaultConfig {
     minSdk 26
     versionCode 1
-    versionName "0.3.3"
+    versionName "0.4.3"
   }
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_17

package/android/src/main/AndroidManifest.xml

@@ -5,6 +5,7 @@
     android:name="android.permission.BLUETOOTH_SCAN"
     android:usesPermissionFlags="neverForLocation" />
   <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
-  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="30" />
+  <!-- Some OEMs (e.g. Samsung) still filter BLE scan results without location on API 31+. -->
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
   <uses-feature android:name="android.hardware.bluetooth_le" android:required="false" />
 </manifest>

package/android/src/main/java/expo/modules/tempivosensorbeacon/SensorBeaconNative.java

@@ -181,9 +181,7 @@ final class SensorBeaconNative {
     payload.put("serial", qr.getSerial());
     payload.put("pin", qr.getPin());
     payload.put("model", qr.getModel());
-    payload.put(
-        "sessionType",
-        qr.getSessionType() == TempivoSensorSession.SessionType.LEGACY ? "legacy" : "modern");
+    payload.put("sessionType", "modern");
     payload.put("bluetoothMac", qr.getBluetoothMac());
     return payload;
   }

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

@@ -8,6 +8,7 @@ import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
+import kotlinx.coroutines.launch
 
 class TempivoSensorBeaconModule : Module() {
   private val native = SensorBeaconNative()
@@ -24,8 +25,11 @@ class TempivoSensorBeaconModule : Module() {
 
     AsyncFunction("startScan") {
       try {
+        val ctx = appContext
         native.startScan(requireContext()) { payload ->
-          sendEvent("onDeviceFound", payload)
+          ctx.mainQueue.launch {
+            sendEvent("onDeviceFound", payload)
+          }
         }
       } catch (error: Throwable) {
         throw error.toSensorException()
@@ -101,7 +105,12 @@ class TempivoSensorBeaconModule : Module() {
 
   private fun blePermissions(): Array<String> {
     return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      arrayOf(Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT)
+      arrayOf(
+        Manifest.permission.BLUETOOTH_SCAN,
+        Manifest.permission.BLUETOOTH_CONNECT,
+        // Some Samsung/OEM builds still filter scan results without location granted.
+        Manifest.permission.ACCESS_FINE_LOCATION,
+      )
     } else {
       arrayOf(
         Manifest.permission.ACCESS_FINE_LOCATION,

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

@@ -4,7 +4,6 @@ import android.app.Application
 import kotlinx.coroutines.delay
 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
@@ -50,103 +49,50 @@ internal object SensorBleRuntime {
         serial: String,
         bluetoothMac: String,
         pin: Int,
-        legacy: Boolean,
     ): 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 c =
+            EfentoBluetooth.sensorConnection(
+                deviceID = serial,
+                bluetoothMacAddress = mac,
+                resetCode = pin,
+                encryptionKey = "",
+            )
+        c.connect()
+        if (pin >= 0) c.resetCode = pin
+        return Session(c)
     }
 
     suspend fun disconnect(session: Session?) {
-        when (session) {
-            is Session.Modern -> runCatching { session.connection.disconnect() }
-            is Session.Legacy -> runCatching { session.connection.disconnect() }
-            null -> Unit
-        }
+        session?.let { runCatching { it.connection.disconnect() } }
     }
 
-    suspend fun readConfiguration(session: Session): SensorConfiguration {
-        return when (session) {
-            is Session.Modern -> modernGetConfiguration(session.connection)
-            is Session.Legacy ->
-                throw TempivoSensorException(
-                    TempivoSensorException.Code.UNSUPPORTED_COMMAND,
-                    "Configuration rules require a current-generation sensor session.",
-                )
-        }
-    }
+    suspend fun readConfiguration(session: Session): SensorConfiguration =
+        modernGetConfiguration(session.connection)
 
     suspend fun writeConfiguration(session: Session, cfg: TempivoSensorConfiguration) {
         val (rules, calendars) = compileRules(cfg)
-        when (session) {
-            is Session.Modern -> {
-                val base = modernGetConfiguration(session.connection)
-                var next = base.copy(rules = rules.take(12), ruleCalendars = calendars.take(6))
-                cfg.measurementIntervalMinutes?.let { minutes ->
-                    val baseSec = (minutes * 60.0).toInt().coerceAtLeast(1)
-                    next = next.copy(measurementPeriod = MeasurementPeriod(baseSec, 1))
-                }
-                cfg.transmissionIntervalSeconds?.let { sec ->
-                    next = next.copy(transmissionInterval = TransmissionInterval(sec))
-                }
-                session.connection.commands.setConfiguration(next) { }
-            }
-            is Session.Legacy ->
-                throw TempivoSensorException(
-                    TempivoSensorException.Code.UNSUPPORTED_COMMAND,
-                    "Configuration rules require a current-generation sensor session.",
-                )
+        val base = modernGetConfiguration(session.connection)
+        var next = base.copy(rules = rules.take(12), ruleCalendars = calendars.take(6))
+        cfg.measurementIntervalMinutes?.let { minutes ->
+            val baseSec = (minutes * 60.0).toInt().coerceAtLeast(1)
+            next = next.copy(measurementPeriod = MeasurementPeriod(baseSec, 1))
+        }
+        cfg.transmissionIntervalSeconds?.let { sec ->
+            next = next.copy(transmissionInterval = TransmissionInterval(sec))
         }
+        session.connection.commands.setConfiguration(next) { }
     }
 
     suspend fun triggerTransmission(session: Session): TempivoSensorSession.TriggerResult {
-        return when (session) {
-            is Session.Modern -> {
-                session.connection.commands.triggerCommunicationWithServer { }
-                TempivoSensorSession.TriggerResult(ok = true, supported = true)
-            }
-            is Session.Legacy -> {
-                try {
-                    session.connection.cellularCommands.triggerCommunicationWithServer { }
-                    TempivoSensorSession.TriggerResult(ok = true, supported = true)
-                } catch (e: UnsupportedCommandException) {
-                    TempivoSensorSession.TriggerResult(ok = false, supported = false)
-                }
-            }
-        }
+        session.connection.commands.triggerCommunicationWithServer { }
+        return TempivoSensorSession.TriggerResult(ok = true, supported = true)
     }
 
     suspend fun readCalibration(session: Session): TempivoSensorCalibration {
-        return when (session) {
-            is Session.Modern -> {
-                val ext = session.connection.commands.getExtendedConfiguration { }
-                TempivoSensorCalibrationDecoder.decode(ext.laboratoryCalibrationTimestamp)
-            }
-            is Session.Legacy -> TempivoSensorCalibration(null, null)
-        }
+        val ext = session.connection.commands.getExtendedConfiguration { }
+        return TempivoSensorCalibrationDecoder.decode(ext.laboratoryCalibrationTimestamp)
     }
 
     fun compileRules(cfg: TempivoSensorConfiguration): Pair<List<Rule>, List<RuleCalendar>> =
@@ -171,8 +117,5 @@ internal object SensorBleRuntime {
         throw last ?: TempivoSensorException(TempivoSensorException.Code.UNKNOWN, "Could not read configuration.")
     }
 
-    sealed class Session {
-        class Modern(val connection: SensorConnection) : Session()
-        class Legacy(val connection: SensorLegacyConnection) : Session()
-    }
+    class Session(val connection: SensorConnection)
 }

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

@@ -0,0 +1,138 @@
+package com.tempivo.sensor.beacon
+
+import pl.efento.mobile.bluetooth.measurement.Measurement
+import pl.efento.mobile.bluetooth.model.Sensor
+import kotlin.math.abs
+import kotlin.math.floor
+
+/** Advertisement telemetry from Efento SDK [Sensor] (same path as Tempivo Capacitor app). */
+internal object SensorSdkScanTelemetry {
+    fun fromSensor(sensor: Sensor): TempivoSensorBeaconTelemetry {
+        val readings = buildReadings(sensor)
+        val summary = sensorAdvertisementSummary(sensor, readings.size)
+        val fw = sensor.softwareVersion
+        val lts = fw.lts ?: 0
+        val periodBase = sensor.measurementPeriod.base
+        val periodFactor = sensor.measurementPeriod.factor
+        val intervalSec =
+            if (periodBase > 0) {
+                periodBase * (if (periodFactor == 0) 1 else periodFactor)
+            } else {
+                null
+            }
+        val ts = sensor.measurementsTimestamp
+        return TempivoSensorBeaconTelemetry(
+            firmware = "${fw.major}.${fw.minor}.$lts",
+            batteryOk = sensor.batteryStatus.name.contains("OK", ignoreCase = true),
+            encryptionEnabled = sensor.encryptionStatus.name.contains("ENABLED", ignoreCase = true),
+            cellularStatus = resolveCellularStatus(sensor),
+            measurementCounter = sensor.counter.takeIf { it > 0 }?.toLong(),
+            readingTimestampUnix = ts.takeIf { it > 0 },
+            measurementIntervalSeconds = intervalSec,
+            readings = readings,
+            readingsCount = readings.size,
+            summary = summary,
+        )
+    }
+
+    fun deviceFromSensor(sensor: Sensor): TempivoSensorBeaconDevice {
+        val mac = sensor.bluetoothMacAddress.withColons
+        val serial = TempivoSensorBeaconDecoder.macKey(mac)
+        val telemetry = fromSensor(sensor)
+        return TempivoSensorBeaconDevice(
+            deviceId = sensor.id,
+            bluetoothMacAddress = mac,
+            serialNumber = serial,
+            rssi = sensor.rssi,
+            telemetry = telemetry,
+            summary = telemetry.summary ?: serial,
+        )
+    }
+
+    private fun sensorAdvertisementSummary(
+        sensor: Sensor,
+        readingsCount: Int,
+    ): String {
+        val parts = measurementSummaryParts(sensor)
+        if (parts.isNotEmpty()) return parts.take(4).joinToString(" · ")
+        val fw = sensor.softwareVersion
+        val lts = fw.lts ?: 0
+        return if (readingsCount == 0) {
+            "${fw.major}.${fw.minor}.$lts"
+        } else {
+            "${fw.major}.${fw.minor}.$lts"
+        }
+    }
+
+    private fun buildReadings(sensor: Sensor): List<TempivoSensorBeaconReading> {
+        val out = mutableListOf<TempivoSensorBeaconReading>()
+        for ((_, measurement) in sensor.measurements) {
+            if (!measurement.isValid) continue
+            out +=
+                TempivoSensorBeaconReading(
+                    typeHex = measurementTypeHex(measurement),
+                    raw24 = 0,
+                    text = formatMeasurementText(measurement),
+                )
+        }
+        return out
+    }
+
+    private fun measurementTypeHex(m: Measurement<*>): String {
+        val typeName = m.type.toString()
+        return Regex("0x[0-9A-Fa-f]+").find(typeName)?.value ?: typeName
+    }
+
+    private fun formatMeasurementText(m: Measurement<*>): String {
+        val type = m.type.toString().substringAfterLast('.').replace('_', ' ')
+        val v = m.value
+        return when (v) {
+            is Double -> "$type ${formatNum(v)}"
+            is Float -> "$type ${formatNum(v.toDouble())}"
+            is Int -> "$type $v"
+            is Long -> "$type $v"
+            else -> "$type $v"
+        }
+    }
+
+    private fun formatNum(v: Double): String =
+        if (abs(v - floor(v)) < 0.0001) {
+            v.toInt().toString()
+        } else {
+            v.toString()
+        }
+
+    private fun measurementSummaryParts(sensor: Sensor): List<String> {
+        val out = mutableListOf<String>()
+        for ((_, measurement) in sensor.measurements) {
+            if (!measurement.isValid) continue
+            out.add(formatMeasurementText(measurement))
+        }
+        return out
+    }
+
+    private fun resolveCellularStatus(sensor: Sensor): String? {
+        sensor.cellularStatus?.let { return mapCellularStatus(it) }
+        return mapConnectivityToCellular(sensor.connectivityStatus)
+    }
+
+    private fun mapCellularStatus(status: Sensor.CellularStatus): String =
+        when (status) {
+            Sensor.CellularStatus.COMMUNICATION_WITH_SERVER_DISABLED -> "ble_only"
+            Sensor.CellularStatus.OPERATING_CORRECTLY -> "cell_ok"
+            Sensor.CellularStatus.CLOUD_PROBLEM -> "no_server"
+            Sensor.CellularStatus.NETWORK_PROBLEM -> "net_issue"
+        }
+
+    private fun mapConnectivityToCellular(status: Sensor.ConnectivityStatus): String? {
+        val n = status.name.uppercase()
+        return when {
+            n.contains("BLE_ONLY") || n.contains("BLUETOOTH_ONLY") -> "ble_only"
+            n.contains("SERVER") || n.contains("CLOUD") -> "no_server"
+            n.contains("NETWORK") || n.contains("NET") -> "net_issue"
+            n.contains("CELLULAR") && n.contains("OK") -> "cell_ok"
+            n.contains("WORKING") && n.contains("CORRECT") -> "cell_ok"
+            else -> null
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
 package com.tempivo.sensor.beacon
 
+import android.bluetooth.le.ScanRecord
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
@@ -116,6 +117,58 @@ object TempivoSensorBeaconDecoder {
         return out
     }
 
+    /**
+     * All Tempivo manufacturer payloads from a scan record.
+     *
+     * `getBytes()` may contain only the advertising `0x03` block while
+     * [ScanRecord.getManufacturerSpecificData] holds a **concatenated** `0x03` + `0x04` blob
+     * (Android merges both when they share company id `0x026C`). Always merge every source.
+     */
+    fun manufacturerPayloadsFromScanRecord(record: ScanRecord): List<ByteArray> {
+        val out = mutableListOf<ByteArray>()
+        fun addUnique(payloads: List<ByteArray>) {
+            for (payload in payloads) {
+                if (payload.isEmpty()) continue
+                for (part in expandConcatenatedManufacturerPayload(payload)) {
+                    if (out.none { it.contentEquals(part) }) {
+                        out += part
+                    }
+                }
+            }
+        }
+
+        addUnique(manufacturerPayloadsFromScanRecordBytes(record.bytes))
+
+        val sparse = record.manufacturerSpecificData
+        if (sparse != null) {
+            for (i in 0 until sparse.size()) {
+                if (sparse.keyAt(i) == MANUFACTURER_COMPANY_ID) {
+                    sparse.valueAt(i)?.let { addUnique(listOf(it)) }
+                }
+            }
+        }
+        record.getManufacturerSpecificData(MANUFACTURER_COMPANY_ID)?.let { addUnique(listOf(it)) }
+
+        return out
+    }
+
+    /**
+     * Android often returns one manufacturer blob with adv `0x03` immediately followed by
+     * scan-response `0x04`. Raw AD parsing may only surface the first block.
+     */
+    private fun expandConcatenatedManufacturerPayload(payload: ByteArray): List<ByteArray> {
+        if (payload.size > ADV_FRAME_03_LEN && (payload[0].toInt() and 0xFF) == 0x03) {
+            val tail = payload.copyOfRange(ADV_FRAME_03_LEN, payload.size)
+            if (tail.isNotEmpty() && (tail[0].toInt() and 0xFF) == 0x04) {
+                return listOf(
+                    payload.copyOfRange(0, ADV_FRAME_03_LEN),
+                    tail,
+                )
+            }
+        }
+        return listOf(payload)
+    }
+
     /**
      * @return true if any `0x03` / `0x04` frame was stored.
      */