@tempivo/sensor-beacon 0.3.2 → 0.4.3

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
@@ -12,12 +13,18 @@ import kotlin.math.floor
  *
  * Android [android.bluetooth.le.ScanRecord.getManufacturerSpecificData] returns the payload **after**
  * the 2-byte company id — i.e. starts with `0x03` / `0x04`, not `6C 02`.
+ *
+ * Prefer [manufacturerPayloadsFromScanRecordBytes]: `getManufacturerSpecificData(0x026C)` can keep only
+ * one blob when both advertisement (`0x03`) and scan response (`0x04`) share the same company id.
  */
 object TempivoSensorBeaconDecoder {
 
     /** Bluetooth SIG company identifier (little-endian on air: `6C 02`). */
     const val MANUFACTURER_COMPANY_ID: Int = 0x026C
 
+    /** AD type for Manufacturer Specific Data. */
+    private const val AD_TYPE_MANUFACTURER: Int = 0xFF
+
     const val ADV_FRAME_03_LEN = 22
 
     private data class MeasureSpec(
@@ -62,20 +69,6 @@ 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
@@ -95,6 +88,87 @@ object TempivoSensorBeaconDecoder {
         return keys.toList()
     }
 
+    /**
+     * Extract every Tempivo manufacturer payload from a raw [android.bluetooth.le.ScanRecord] byte
+     * array (AD length/type structures). Each returned blob starts with frame tag `0x03` / `0x04`
+     * (company id already stripped), matching [getManufacturerSpecificData].
+     */
+    fun manufacturerPayloadsFromScanRecordBytes(scanRecordBytes: ByteArray?): List<ByteArray> {
+        if (scanRecordBytes == null || scanRecordBytes.isEmpty()) return emptyList()
+        val out = mutableListOf<ByteArray>()
+        var i = 0
+        val n = scanRecordBytes.size
+        while (i < n) {
+            val len = scanRecordBytes[i].toInt() and 0xFF
+            if (len == 0) break
+            if (i + 1 + len > n) break
+            val type = scanRecordBytes[i + 1].toInt() and 0xFF
+            if (type == AD_TYPE_MANUFACTURER && len >= 3) {
+                val company =
+                    (scanRecordBytes[i + 2].toInt() and 0xFF) or
+                        ((scanRecordBytes[i + 3].toInt() and 0xFF) shl 8)
+                if (company == MANUFACTURER_COMPANY_ID && len > 3) {
+                    // AD length counts type + company + payload; payload starts at i+4.
+                    out += scanRecordBytes.copyOfRange(i + 4, i + 1 + len)
+                }
+            }
+            i += 1 + len
+        }
+        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.
      */
@@ -115,7 +189,7 @@ object TempivoSensorBeaconDecoder {
                         val frame = fr.copyOf(ADV_FRAME_03_LEN)
                         val keys = lookupKeys(primaryMacKey, serialKeyFromAdv03(frame))
                         for (key in keys) {
-                            if (last03[key] != frame) {
+                            if (!last03[key].contentEquals(frame)) {
                                 last03[key] = frame
                                 changed = true
                             }
@@ -129,16 +203,23 @@ object TempivoSensorBeaconDecoder {
                             if (existing != null && existing.isNotEmpty() && (existing[0].toInt() and 0xFF) == 0x03) {
                                 continue
                             }
-                            if (last03[key] != fr) {
+                            if (!last03[key].contentEquals(fr)) {
                                 last03[key] = fr
                                 changed = true
                             }
                         }
                     }
                 0x04 -> {
-                    val keys = lookupKeys(primaryMacKey)
+                    // Also index under any serial already learned from `0x03` for this MAC.
+                    val serialFromCached03 =
+                        lookupKeys(primaryMacKey)
+                            .asSequence()
+                            .mapNotNull { last03[it] }
+                            .mapNotNull { serialKeyFromAdv03(it) }
+                            .firstOrNull()
+                    val keys = lookupKeys(primaryMacKey, serialFromCached03)
                     for (key in keys) {
-                        if (last04[key] != fr) {
+                        if (!last04[key].contentEquals(fr)) {
                             last04[key] = fr
                             changed = true
                         }

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

@@ -1,6 +1,7 @@
 package com.tempivo.sensor.beacon
 
 import android.Manifest
+import android.app.Application
 import android.bluetooth.BluetoothManager
 import android.bluetooth.le.ScanCallback
 import android.bluetooth.le.ScanResult
@@ -11,12 +12,23 @@ import android.os.Build
 import androidx.core.content.ContextCompat
 import java.util.Locale
 import java.util.concurrent.ConcurrentHashMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import pl.efento.mobile.bluetooth.EfentoBluetooth
+import pl.efento.mobile.bluetooth.model.Device as EfentoDevice
+import pl.efento.mobile.bluetooth.model.Sensor
 
 /**
- * Active BLE scan for Tempivo sensors (manufacturer `0x026C`). Advertisement decode only; no GATT.
- *
- * The host app must declare and grant runtime BLE permissions (`BLUETOOTH_SCAN` on API 31+,
- * or `ACCESS_FINE_LOCATION` on older APIs).
+ * Tempivo sensor discovery — same strategy as the Tempivo Capacitor app:
+ * alternate Efento SDK `deviceFlow()` with manufacturer `0x026C` adv-only windows.
  */
 class TempivoSensorBeaconScanner(
     context: Context,
@@ -27,7 +39,6 @@ class TempivoSensorBeaconScanner(
 
     class ScanNotPermittedException(message: String) : Exception(message)
 
-    private val appContext = context.applicationContext
     data class SeenDevice(
         val deviceId: String,
         val bluetoothMac: String,
@@ -36,30 +47,40 @@ class TempivoSensorBeaconScanner(
         val encryptionEnabled: Boolean?,
     )
 
+    companion object {
+        private const val SDK_SCAN_WINDOW_MS = 12_000L
+        private const val ADV_SCAN_WINDOW_MS = 5_000L
+    }
+
+    private val application = context.applicationContext as Application
     private val advLast03 = ConcurrentHashMap<String, ByteArray>()
     private val advLast04 = ConcurrentHashMap<String, ByteArray>()
     private val lastSeen = ConcurrentHashMap<String, SeenDevice>()
+    private val lastSensorBySerial = ConcurrentHashMap<String, Sensor>()
     private var listener: Listener? = null
     private var scanning = false
+    private var advOnlyWindowActive = false
+    private val scanScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    private var scanJob: Job? = null
 
     private val leScanCallback =
         object : ScanCallback() {
             override fun onScanResult(callbackType: Int, result: ScanResult) {
-                handleScanResult(result)
+                handleAdvScanResult(result)
             }
 
             override fun onBatchScanResults(results: MutableList<ScanResult>) {
                 for (result in results) {
-                    handleScanResult(result)
+                    handleAdvScanResult(result)
                 }
             }
         }
 
-    /** Clears cached `0x03` / `0x04` frames. */
     fun clearCache() {
         advLast03.clear()
         advLast04.clear()
         lastSeen.clear()
+        lastSensorBySerial.clear()
     }
 
     fun lookup(serial: String): SeenDevice? {
@@ -68,62 +89,114 @@ class TempivoSensorBeaconScanner(
     }
 
     fun startScan(listener: Listener) {
-        if (scanning) {
-            stopScan()
-        }
+        if (scanning) stopScan()
         if (!hasBleScanPermission()) {
             throw ScanNotPermittedException("BLE scan permission not granted")
         }
-        val scanner = bluetoothLeScanner()
-            ?: throw IllegalStateException("Bluetooth LE scanner unavailable")
+        SensorBleRuntime.initialize(application)
         this.listener = listener
-        val settings =
-            ScanSettings.Builder()
-                .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
-                // Active scan: needed for scan-response frame (`0x04`) with measurements.
-                .setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES)
-                .build()
-        scanner.startScan(null, settings, leScanCallback)
         scanning = true
+        advOnlyWindowActive = false
+        clearCache()
+        stopParallelAdvScan()
+        scanJob =
+            scanScope.launch {
+                val sdkScanner = EfentoBluetooth.scanner()
+                while (isActive && scanning) {
+                    advOnlyWindowActive = false
+                    val sdkCollect =
+                        launch {
+                            sdkScanner
+                                .deviceFlow()
+                                .catch { /* keep alternating windows alive */ }
+                                .collect { device ->
+                                    emitSdkDevice(device)
+                                }
+                        }
+                    delay(SDK_SCAN_WINDOW_MS)
+                    sdkCollect.cancel()
+                    sdkCollect.join()
+                    if (!isActive || !scanning) break
+
+                    advOnlyWindowActive = true
+                    withContext(Dispatchers.Main) { startParallelAdvScan() }
+                    delay(ADV_SCAN_WINDOW_MS)
+                    advOnlyWindowActive = false
+                    withContext(Dispatchers.Main) { stopParallelAdvScan() }
+                }
+            }
     }
 
     fun stopScan() {
-        if (!scanning) return
-        val scanner = bluetoothLeScanner() ?: return
-        if (!hasBleScanPermission()) {
-            scanning = false
-            listener = null
-            return
-        }
-        try {
-            scanner.stopScan(leScanCallback)
-        } catch (_: Exception) {
-        }
         scanning = false
+        advOnlyWindowActive = false
+        scanJob?.cancel()
+        scanJob = null
+        stopParallelAdvScan()
         listener = null
     }
 
     fun isScanning(): Boolean = scanning
 
-    private fun handleScanResult(result: ScanResult) {
-        val md =
-            result.scanRecord?.getManufacturerSpecificData(TempivoSensorBeaconDecoder.MANUFACTURER_COMPANY_ID)
-                ?: return
+    private fun emitSdkDevice(device: EfentoDevice) {
+        if (device !is Sensor) return
+        val mapped = SensorSdkScanTelemetry.deviceFromSensor(device)
+        val serial = mapped.serialNumber.uppercase(Locale.US)
+        lastSensorBySerial[serial] = device
+        rememberSeen(mapped)
+        listener?.onDeviceFound(mapped)
+    }
+
+    private fun handleAdvScanResult(result: ScanResult) {
+        if (!advOnlyWindowActive) return
+        val record = result.scanRecord ?: return
         val addr = result.device?.address ?: return
         val key = TempivoSensorBeaconDecoder.macKey(addr)
-        val changed =
+        val payloads = TempivoSensorBeaconDecoder.manufacturerPayloadsFromScanRecord(record)
+        if (payloads.isEmpty()) return
+
+        for (md in payloads) {
             TempivoSensorBeaconDecoder.ingestManufacturerPayload(md, key, advLast03, advLast04)
-        if (!changed && !advLast03.containsKey(key) && !advLast04.containsKey(key)) {
+        }
+        val serialHint =
+            payloads.asSequence()
+                .mapNotNull { TempivoSensorBeaconDecoder.serialKeyFromAdv03(it) }
+                .firstOrNull()
+        val lookupKeys = TempivoSensorBeaconDecoder.lookupKeys(key, serialHint)
+        if (lookupKeys.none { advLast03.containsKey(it) || advLast04.containsKey(it) }) {
             return
         }
-        val device = buildDevice(result, key) ?: return
+
+        val advSerial =
+            lookupKeys.asSequence()
+                .mapNotNull { advLast03[it] }
+                .mapNotNull { TempivoSensorBeaconDecoder.serialKeyFromAdv03(it) }
+                .firstOrNull()
+        val serial = (advSerial ?: key).uppercase(Locale.US)
+
+        lastSensorBySerial[serial]?.let { sensor ->
+            val refreshed = SensorSdkScanTelemetry.deviceFromSensor(sensor)
+            rememberSeen(refreshed)
+            listener?.onDeviceFound(refreshed)
+            return
+        }
+
+        val device = buildAdvDevice(result, key, lookupKeys) ?: return
+        rememberSeen(device)
         listener?.onDeviceFound(device)
     }
 
-    private fun buildDevice(result: ScanResult, key: String): TempivoSensorBeaconDevice? {
+    private fun buildAdvDevice(
+        result: ScanResult,
+        key: String,
+        lookupKeys: List<String>,
+    ): TempivoSensorBeaconDevice? {
         val addr = result.device?.address ?: return null
-        val frame = advLast03[key]
-        val advSerial = frame?.let { TempivoSensorBeaconDecoder.serialKeyFromAdv03(it) }
+        val advSerial =
+            lookupKeys.asSequence()
+                .mapNotNull { advLast03[it] }
+                .mapNotNull { TempivoSensorBeaconDecoder.serialKeyFromAdv03(it) }
+                .firstOrNull()
         val serial = (advSerial ?: key).uppercase(Locale.US)
         val macColons = macWithColonsFromKey(if (key.length == 12) key else serial)
         val telemetry =
@@ -132,43 +205,70 @@ class TempivoSensorBeaconScanner(
                 advLast03,
                 advLast04,
             )
-        val summary =
-            telemetry?.summary?.takeIf { it.isNotEmpty() }
-                ?: serial
-        val device =
-            TempivoSensorBeaconDevice(
-                deviceId = addr,
-                bluetoothMacAddress = macColons,
-                serialNumber = serial,
-                rssi = result.rssi,
-                telemetry = telemetry,
-                summary = summary,
-            )
+        val summary = telemetry?.summary?.takeIf { it.isNotEmpty() } ?: serial
+        return TempivoSensorBeaconDevice(
+            deviceId = addr,
+            bluetoothMacAddress = macColons,
+            serialNumber = serial,
+            rssi = result.rssi,
+            telemetry = telemetry,
+            summary = summary,
+        )
+    }
+
+    private fun rememberSeen(device: TempivoSensorBeaconDevice) {
         val seen =
             SeenDevice(
-                deviceId = addr,
-                bluetoothMac = macColons,
-                serial = serial,
-                firmware = telemetry?.firmware,
-                encryptionEnabled = telemetry?.encryptionEnabled,
+                deviceId = device.deviceId,
+                bluetoothMac = device.bluetoothMacAddress,
+                serial = device.serialNumber,
+                firmware = device.telemetry?.firmware,
+                encryptionEnabled = device.telemetry?.encryptionEnabled,
             )
-        lastSeen[serial] = seen
-        lastSeen[key.uppercase(Locale.US)] = seen
-        return device
+        lastSeen[device.serialNumber.uppercase(Locale.US)] = seen
+        lastSeen[TempivoSensorBeaconDecoder.macKey(device.serialNumber)] = seen
+    }
+
+    private fun startParallelAdvScan() {
+        if (!hasBleScanPermission()) return
+        val scanner = bluetoothLeScanner() ?: return
+        val settings =
+            ScanSettings.Builder()
+                .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
+                .setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES)
+                .build()
+        try {
+            scanner.startScan(null, settings, leScanCallback)
+        } catch (_: Exception) {
+        }
+    }
+
+    private fun stopParallelAdvScan() {
+        if (!hasBleScanPermission()) return
+        val scanner = bluetoothLeScanner() ?: return
+        try {
+            scanner.stopScan(leScanCallback)
+        } catch (_: Exception) {
+        }
     }
 
     private fun bluetoothLeScanner() =
-        (appContext.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager)
+        (application.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager)
             ?.adapter
             ?.bluetoothLeScanner
 
     private fun hasBleScanPermission(): Boolean {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            return ContextCompat.checkSelfPermission(appContext, Manifest.permission.BLUETOOTH_SCAN) ==
-                PackageManager.PERMISSION_GRANTED
+            val scanGranted =
+                ContextCompat.checkSelfPermission(application, Manifest.permission.BLUETOOTH_SCAN) ==
+                    PackageManager.PERMISSION_GRANTED
+            val locationGranted =
+                ContextCompat.checkSelfPermission(application, Manifest.permission.ACCESS_FINE_LOCATION) ==
+                    PackageManager.PERMISSION_GRANTED
+            return scanGranted && locationGranted
         }
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            return ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_FINE_LOCATION) ==
+            return ContextCompat.checkSelfPermission(application, Manifest.permission.ACCESS_FINE_LOCATION) ==
                 PackageManager.PERMISSION_GRANTED
         }
         return true

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

@@ -1,27 +1,10 @@
 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,

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

@@ -26,10 +26,16 @@ data class TempivoSchedule(
 data class TempivoSensorConfiguration(
     val temperatureAlerts: List<TempivoTemperatureAlert>,
     val schedule: TempivoSchedule,
+    val measurementIntervalMinutes: Double? = null,
+    val transmissionIntervalSeconds: Int? = null,
 )
 
 object TempivoSensorProfile {
     private val timeRe = Regex("^([01]\\d|2[0-3]):([0-5]\\d)$")
+    private const val MIN_MEASUREMENT_MINUTES = 60.0
+    private const val MAX_MEASUREMENT_MINUTES = 600.0
+    private const val MIN_TRANSMISSION_SECONDS = 3600
+    private const val MAX_TRANSMISSION_SECONDS = 604_800
 
     fun parseJson(json: String): TempivoSensorConfiguration {
         val root =
@@ -47,7 +53,11 @@ object TempivoSensorProfile {
         }
         val body =
             root.optJSONObject("profile")?.takeIf {
-                it.has("temperatureAlerts") || it.has("schedule") || it.has("slug")
+                it.has("temperatureAlerts") ||
+                    it.has("schedule") ||
+                    it.has("slug") ||
+                    it.has("measurementIntervalMinutes") ||
+                    it.has("transmissionIntervalSeconds")
             } ?: root
         if (!body.has("temperatureAlerts") && body.has("alarmRules")) {
             throw invalid("Use a config profile with temperatureAlerts (GET /devices/config-profiles/{slug}), not alarmRules.")
@@ -58,7 +68,13 @@ object TempivoSensorProfile {
             val item = arr.optJSONObject(i) ?: throw invalid("temperatureAlerts[$i] must be an object.")
             alerts.add(parseAlert(item, i))
         }
-        return TempivoSensorConfiguration(alerts, parseSchedule(body.optJSONObject("schedule")))
+        val intervals = parseOptionalIntervals(body)
+        return TempivoSensorConfiguration(
+            alerts,
+            parseSchedule(body.optJSONObject("schedule")),
+            measurementIntervalMinutes = intervals.first,
+            transmissionIntervalSeconds = intervals.second,
+        )
     }
 
     fun toJson(cfg: TempivoSensorConfiguration): String {
@@ -90,9 +106,50 @@ object TempivoSensorProfile {
             s.put("utcOffsetMinutes", cfg.schedule.utcOffsetMinutes)
         }
         root.put("schedule", s)
+        cfg.measurementIntervalMinutes?.let { root.put("measurementIntervalMinutes", it) }
+        cfg.transmissionIntervalSeconds?.let { root.put("transmissionIntervalSeconds", it) }
         return root.toString()
     }
 
+    private fun parseOptionalIntervals(body: JSONObject): Pair<Double?, Int?> {
+        var measurement: Double? = null
+        var transmission: Int? = null
+        if (body.has("measurementIntervalMinutes") && !body.isNull("measurementIntervalMinutes")) {
+            val n = body.optDouble("measurementIntervalMinutes")
+            if (!n.isFinite() || n <= 0) {
+                throw invalid("measurementIntervalMinutes must be a positive number.")
+            }
+            if (n < MIN_MEASUREMENT_MINUTES) {
+                throw invalid("measurementIntervalMinutes must be at least $MIN_MEASUREMENT_MINUTES (1 hour).")
+            }
+            if (n > MAX_MEASUREMENT_MINUTES) {
+                throw invalid("measurementIntervalMinutes must be at most $MAX_MEASUREMENT_MINUTES.")
+            }
+            measurement = n
+        }
+        if (body.has("transmissionIntervalSeconds") && !body.isNull("transmissionIntervalSeconds")) {
+            val asDouble = body.optDouble("transmissionIntervalSeconds")
+            if (!asDouble.isFinite() || asDouble <= 0 || asDouble != kotlin.math.floor(asDouble)) {
+                throw invalid("transmissionIntervalSeconds must be a positive integer.")
+            }
+            val n = asDouble.toInt()
+            if (n < MIN_TRANSMISSION_SECONDS) {
+                throw invalid("transmissionIntervalSeconds must be at least $MIN_TRANSMISSION_SECONDS (1 hour).")
+            }
+            if (n > MAX_TRANSMISSION_SECONDS) {
+                throw invalid("transmissionIntervalSeconds must be at most $MAX_TRANSMISSION_SECONDS.")
+            }
+            transmission = n
+        }
+        if (measurement != null && transmission != null) {
+            val maxTx = measurement * 60.0 * 60.0
+            if (transmission > maxTx) {
+                throw invalid("transmissionIntervalSeconds must be at most 60 times the measurement interval.")
+            }
+        }
+        return measurement to transmission
+    }
+
     private fun parseAlert(item: JSONObject, index: Int): TempivoTemperatureAlert {
         val channel = item.optString("channel")
         if (channel != "ambient" && channel != "probe") {

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

@@ -7,7 +7,6 @@ data class TempivoSensorQr(
     val serial: String,
     val pin: String,
     val model: String?,
-    val sessionType: TempivoSensorSession.SessionType,
     val bluetoothMac: String,
 )
 
@@ -30,22 +29,13 @@ object TempivoSensorQrParser {
         }
     }
 
-    fun sessionTypeFromModel(model: String?): TempivoSensorSession.SessionType {
-        if (model.isNullOrBlank()) return TempivoSensorSession.SessionType.MODERN
+    fun assertSupportedModel(model: String) {
         val m = model.trim().uppercase(Locale.US).replace("-", "")
-        return if (m == "HC5" || m.startsWith("6")) {
-            TempivoSensorSession.SessionType.LEGACY
-        } else {
-            TempivoSensorSession.SessionType.MODERN
-        }
-    }
-
-    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)
+        if (m == "HC5") {
+            throw TempivoSensorException(
+                TempivoSensorException.Code.INVALID_QR,
+                "HC5 is not supported by the partner SDK. Use HC7 sensors.",
+            )
         }
     }
 
@@ -70,12 +60,12 @@ object TempivoSensorQrParser {
             throw TempivoSensorException(TempivoSensorException.Code.INVALID_QR, "QR is missing PIN.")
         }
         val model = rec.optString("model").trim().ifEmpty { DEFAULT_MODEL }
+        assertSupportedModel(model)
         val hex = if (serial.length == 12) serial else serial.takeLast(12)
         return TempivoSensorQr(
             serial = serial,
             pin = pin,
             model = model,
-            sessionType = sessionTypeFromModel(model),
             bluetoothMac = bluetoothMacFromSerial(hex),
         )
     }