@tempivo/sensor-beacon 0.3.3 → 0.4.7

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

@@ -2,9 +2,7 @@ package com.tempivo.sensor.beacon
 
 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
@@ -25,7 +23,7 @@ internal object SensorBleRuntime {
         if (initialized) return
         synchronized(initMonitor) {
             if (initialized) return
-            EfentoBluetooth.init(application)
+            SensorBleVendor.init(application)
             initialized = true
         }
     }
@@ -47,106 +45,63 @@ internal object SensorBleRuntime {
 
     suspend fun connect(
         application: Application,
-        serial: String,
+        deviceId: String,
         bluetoothMac: String,
-        pin: Int,
-        legacy: Boolean,
+        pin: String,
     ): Session {
         initialize(application)
+        val creds = BleConnectCredentialsResolver.fromPin(pin)
         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 =
+            SensorBleVendor.sensorConnection(
+                deviceId = deviceId,
+                bluetoothMac = mac,
+                resetCode = creds.resetCode,
+                encryptionKey = creds.encryptionKey,
+            )
+        c.connect()
+        applyConnectCredentials(c, creds)
+        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
-        }
+    private fun applyConnectCredentials(connection: SensorConnection, creds: BleConnectCredentials) {
+        if (creds.resetCode >= 0) connection.resetCode = creds.resetCode
+        if (creds.encryptionKey.isNotEmpty()) connection.encryptionKey = creds.encryptionKey
     }
 
-    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 disconnect(session: Session?) {
+        session?.let { runCatching { it.connection.disconnect() } }
     }
 
+    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)
-                }
-            }
+        return try {
+            session.connection.commands.triggerCommunicationWithServer { }
+            TempivoSensorSession.TriggerResult(ok = true)
+        } catch (e: UnsupportedCommandException) {
+            TempivoSensorSession.TriggerResult(ok = false)
         }
     }
 
     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 +126,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/SensorBleVendor.kt

@@ -0,0 +1,28 @@
+package com.tempivo.sensor.beacon
+
+import android.app.Application
+import pl.efento.mobile.bluetooth.EfentoBluetooth
+import pl.efento.mobile.bluetooth.api.SensorConnection
+import pl.efento.mobile.bluetooth.model.BluetoothMacAddress
+
+/** Single entry point to the bundled sensor BLE runtime (vendor types stay in this file). */
+internal object SensorBleVendor {
+    fun init(application: Application) {
+        EfentoBluetooth.init(application)
+    }
+
+    fun scanner() = EfentoBluetooth.scanner()
+
+    fun sensorConnection(
+        deviceId: String,
+        bluetoothMac: BluetoothMacAddress,
+        resetCode: Int,
+        encryptionKey: String,
+    ): SensorConnection =
+        EfentoBluetooth.sensorConnection(
+            deviceID = deviceId,
+            bluetoothMacAddress = bluetoothMac,
+            resetCode = resetCode,
+            encryptionKey = encryptionKey,
+        )
+}

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

@@ -0,0 +1,20 @@
+package com.tempivo.sensor.beacon
+
+/** Sticker model hint from advertisement firmware. Missing FW → HC7 (modern fleet default). */
+internal object SensorModelHint {
+    const val DEFAULT_MODEL = TempivoSensorQrParser.DEFAULT_MODEL
+
+    fun isMissingFirmware(firmware: String?): Boolean {
+        val t = firmware?.trim().orEmpty()
+        return t.isEmpty() || t == "0.0.0"
+    }
+
+    fun fromFirmware(firmware: String?): String {
+        if (isMissingFirmware(firmware)) return DEFAULT_MODEL
+        val t = firmware!!.trim()
+        if (t.startsWith("FW 5", ignoreCase = true)) return "HC5"
+        val major = Regex("""^(?:FW\s*)?(\d+)\.\d+""", RegexOption.IGNORE_CASE).find(t)?.groupValues?.get(1)?.toIntOrNull()
+            ?: return DEFAULT_MODEL
+        return if (major >= 7) "HC7" else if (major >= 1) "HC5" else DEFAULT_MODEL
+    }
+}

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

@@ -0,0 +1,112 @@
+package com.tempivo.sensor.beacon
+
+import pl.efento.mobile.bluetooth.model.Sensor
+
+/** Advertisement telemetry from runtime scan [Sensor]. */
+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,
+            model = SensorModelHint.fromFirmware(telemetry.firmware),
+            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 = SdkMeasurementFormat.typeHex(measurement),
+                    raw24 = 0,
+                    text = SdkMeasurementFormat.text(measurement),
+                )
+        }
+        return out
+    }
+
+    private fun measurementSummaryParts(sensor: Sensor): List<String> {
+        val out = mutableListOf<String>()
+        for ((_, measurement) in sensor.measurements) {
+            if (!measurement.isValid) continue
+            out.add(SdkMeasurementFormat.text(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.
      */
@@ -236,7 +289,7 @@ object TempivoSensorBeaconDecoder {
                 summaryParts.add(text)
                 readings +=
                     TempivoSensorBeaconReading(
-                        typeHex = String.format(Locale.US, "0x%02X", mtype),
+                        typeHex = SdkMeasurementFormat.labelForTypeId(mtype),
                         raw24 = raw24 and 0xFFFFFF,
                         text = text,
                     )