@tempivo/sensor-beacon 0.1.1 → 0.3.0

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

@@ -0,0 +1,122 @@
+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
+
+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, this)
+  }
+  return CodedException("unknown", message ?: "Sensor request failed.", this)
+}

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/build.gradle

@@ -24,4 +24,7 @@ android {
 
 dependencies {
     implementation "androidx.core:core-ktx:1.17.0"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2"
+    implementation "pl.efento.mobile:bluetooth:2.3.0"
 }

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

@@ -0,0 +1,279 @@
+package com.tempivo.sensor.beacon
+
+import pl.efento.mobile.bluetooth.model.sensor.Action
+import pl.efento.mobile.bluetooth.model.sensor.DisabledCondition
+import pl.efento.mobile.bluetooth.model.sensor.HighThresholdCondition
+import pl.efento.mobile.bluetooth.model.sensor.LogicOperator
+import pl.efento.mobile.bluetooth.model.sensor.LogicOperatorCondition
+import pl.efento.mobile.bluetooth.model.sensor.LogicOperatorConditionParameters
+import pl.efento.mobile.bluetooth.model.sensor.LowThresholdCondition
+import pl.efento.mobile.bluetooth.model.sensor.Rule
+import pl.efento.mobile.bluetooth.model.sensor.RuleCalendar
+import pl.efento.mobile.bluetooth.model.sensor.SensorConfiguration
+import pl.efento.mobile.bluetooth.model.sensor.TemperatureLowHighThresholdConditionParameters
+import pl.efento.mobile.bluetooth.model.sensor.TriggeringMode
+
+/**
+ * Compile Cellular API `temperatureAlerts` + `schedule` into device rules.
+ * Range + `transmitOnReturn` uses the same OR layout as POST /devices/config-profiles.
+ */
+internal object PartnerBleRules {
+    fun compile(cfg: TempivoSensorConfiguration): Pair<List<Rule>, List<RuleCalendar>> {
+        val rules = MutableList(12) { i ->
+            Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION)
+        }
+        val used = BooleanArray(12)
+        val returnLowSlots = mutableListOf<Int>()
+
+        for (alert in cfg.temperatureAlerts) {
+            val channel = if (alert.channel == "probe") 3 else 1
+            val hyst = alert.hysteresisC ?: 1.0
+            when (alert.type) {
+                "min" -> {
+                    val slot = findFree(used) ?: continue
+                    val t = alert.minC ?: continue
+                    val action = if (alert.transmitOnBreach) Action.TRIGGER_TRANSMISSION_WITH_ACK else Action.NO_ACTION
+                    putThreshold(rules, slot, channel, low = true, t, hyst, action)
+                    used[slot] = true
+                }
+                "max" -> {
+                    val slot = findFree(used) ?: continue
+                    val t = alert.maxC ?: continue
+                    val action = if (alert.transmitOnBreach) Action.TRIGGER_TRANSMISSION_WITH_ACK else Action.NO_ACTION
+                    putThreshold(rules, slot, channel, low = false, t, hyst, action)
+                    used[slot] = true
+                }
+                "range" -> {
+                    val low = alert.lowC ?: continue
+                    val high = alert.highC ?: continue
+                    val pair = findPair(used) ?: continue
+                    val ret = alert.transmitOnReturn
+                    val action =
+                        when {
+                            ret -> Action.NO_ACTION
+                            alert.transmitOnBreach -> Action.TRIGGER_TRANSMISSION_WITH_ACK
+                            else -> Action.NO_ACTION
+                        }
+                    putThreshold(rules, pair, channel, low = true, low, hyst, action)
+                    putThreshold(rules, pair + 1, channel, low = false, high, hyst, action)
+                    used[pair] = true
+                    used[pair + 1] = true
+                    if (ret) returnLowSlots.add(pair)
+                }
+            }
+        }
+
+        for (lowSlot in returnLowSlots) {
+            val logicSlot = findFree(used) ?: break
+            rules[logicSlot] =
+                Rule(
+                    logicSlot + 1,
+                    emptySet(),
+                    LogicOperatorCondition(
+                        LogicOperatorConditionParameters(
+                            LogicOperator.OR,
+                            setOf(lowSlot + 1, lowSlot + 2),
+                            emptySet(),
+                            0,
+                            0,
+                        ),
+                    ),
+                    Action.TRIGGER_TRANSMISSION_WITH_ACK,
+                )
+            used[logicSlot] = true
+        }
+
+        val active = rules.filter { it.condition !is DisabledCondition }.map { it.id }.toSet()
+        val calendars = MutableList(6) { i ->
+            RuleCalendar(i + 1, emptySet(), RuleCalendar.Type.Disabled)
+        }
+        if (active.isNotEmpty()) {
+            calendars[0] = RuleCalendar(1, active, weeklyType(cfg.schedule))
+        }
+        return rules to calendars
+    }
+
+    fun decompile(cfg: SensorConfiguration): TempivoSensorConfiguration {
+        val padded = MutableList(12) { i ->
+            cfg.rules.orEmpty().getOrNull(i)
+                ?: Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION)
+        }
+        val orRefs = orSelectedPairs(padded)
+        val used = BooleanArray(12)
+        val alerts = mutableListOf<TempivoTemperatureAlert>()
+
+        for (i in 0..10) {
+            if (used[i] || used[i + 1]) continue
+            val low = padded[i]
+            val high = padded[i + 1]
+            if (low.condition !is LowThresholdCondition || high.condition !is HighThresholdCondition) continue
+            val lowCh = channelOf(low) ?: continue
+            val highCh = channelOf(high) ?: continue
+            if (lowCh != highCh) continue
+            val lowP = (low.condition as LowThresholdCondition).conditionParameters
+            val highP = (high.condition as HighThresholdCondition).conditionParameters
+            val hasReturn = orRefs.any { it.first == i + 1 && it.second == i + 2 }
+            val breachOnly =
+                !hasReturn && (low.action != Action.NO_ACTION || high.action != Action.NO_ACTION)
+            alerts.add(
+                TempivoTemperatureAlert(
+                    type = "range",
+                    channel = lowCh,
+                    lowC = lowP.thresholdValue.toDouble(),
+                    highC = highP.thresholdValue.toDouble(),
+                    hysteresisC = lowP.hysteresisValue?.toDouble() ?: 1.0,
+                    transmitOnBreach = hasReturn || breachOnly,
+                    transmitOnReturn = hasReturn,
+                ),
+            )
+            used[i] = true
+            used[i + 1] = true
+        }
+
+        for (i in 0 until 12) {
+            if (used[i]) continue
+            val r = padded[i]
+            when (val c = r.condition) {
+                is LowThresholdCondition -> {
+                    val ch = channelOf(r) ?: continue
+                    alerts.add(
+                        TempivoTemperatureAlert(
+                            type = "min",
+                            channel = ch,
+                            minC = c.conditionParameters.thresholdValue.toDouble(),
+                            hysteresisC = c.conditionParameters.hysteresisValue?.toDouble() ?: 1.0,
+                            transmitOnBreach = r.action != Action.NO_ACTION,
+                        ),
+                    )
+                    used[i] = true
+                }
+                is HighThresholdCondition -> {
+                    val ch = channelOf(r) ?: continue
+                    alerts.add(
+                        TempivoTemperatureAlert(
+                            type = "max",
+                            channel = ch,
+                            maxC = c.conditionParameters.thresholdValue.toDouble(),
+                            hysteresisC = c.conditionParameters.hysteresisValue?.toDouble() ?: 1.0,
+                            transmitOnBreach = r.action != Action.NO_ACTION,
+                        ),
+                    )
+                    used[i] = true
+                }
+                else -> Unit
+            }
+        }
+
+        return TempivoSensorConfiguration(alerts, decompileSchedule(cfg.ruleCalendars))
+    }
+
+    private fun orSelectedPairs(rules: List<Rule>): List<Pair<Int, Int>> {
+        val out = mutableListOf<Pair<Int, Int>>()
+        for (r in rules) {
+            val c = r.condition as? LogicOperatorCondition ?: continue
+            val p = c.conditionParameters
+            if (p.logicOperator != LogicOperator.OR) continue
+            val ids = p.selectedRules.sorted()
+            if (ids.size == 2) out.add(ids[0] to ids[1])
+        }
+        return out
+    }
+
+    private fun channelOf(rule: Rule): String? =
+        when {
+            rule.channels.contains(3) -> "probe"
+            rule.channels.contains(1) -> "ambient"
+            else -> null
+        }
+
+    private fun findPair(used: BooleanArray): Int? {
+        for (i in 0..10) {
+            if (!used[i] && !used[i + 1]) return i
+        }
+        return null
+    }
+
+    private fun findFree(used: BooleanArray): Int? {
+        for (i in 0 until 12) if (!used[i]) return i
+        return null
+    }
+
+    private fun putThreshold(
+        rules: MutableList<Rule>,
+        slot: Int,
+        channel: Int,
+        low: Boolean,
+        threshold: Double,
+        hyst: Double,
+        action: Action,
+    ) {
+        if (slot !in 0..11) return
+        val params =
+            TemperatureLowHighThresholdConditionParameters(
+                threshold,
+                hyst,
+                TriggeringMode.CONSECUTIVE_SAMPLES,
+                1,
+            )
+        val condition = if (low) LowThresholdCondition(params) else HighThresholdCondition(params)
+        rules[slot] = Rule(slot + 1, setOf(channel), condition, action)
+    }
+
+    private fun decompileSchedule(calendars: List<RuleCalendar>?): TempivoSchedule {
+        val weekly = calendars.orEmpty().map { it.type }.filterIsInstance<RuleCalendar.Type.Weekly>().firstOrNull()
+            ?: return TempivoSchedule(always = true)
+        val days = weekly.days.map { dayToPartnerIndex(it) }.sorted()
+        val always = days.size == 7 && weekly.fromTime == 0 && weekly.toTime >= 1439
+        return if (always) {
+            TempivoSchedule(always = true)
+        } else {
+            TempivoSchedule(
+                always = false,
+                weekdays = days,
+                from = TempivoSensorProfile.hhmmFromMinutes(weekly.fromTime),
+                to = TempivoSensorProfile.hhmmFromMinutes(weekly.toTime),
+                utcOffsetMinutes = weekly.timezoneOffset,
+            )
+        }
+    }
+
+    private fun weeklyType(schedule: TempivoSchedule): RuleCalendar.Type {
+        if (schedule.always) {
+            return RuleCalendar.Type.Weekly(
+                days = RuleCalendar.Type.Weekly.Day.entries.toSet(),
+                fromTime = 0,
+                toTime = 1439,
+                timezoneOffset = 0,
+            )
+        }
+        val days = schedule.weekdays.map { partnerIndexToDay(it) }.toSet()
+        return RuleCalendar.Type.Weekly(
+            days = days,
+            fromTime = TempivoSensorProfile.minutesFromHhmm(schedule.from ?: "00:00"),
+            toTime = TempivoSensorProfile.minutesFromHhmm(schedule.to ?: "23:59"),
+            timezoneOffset = schedule.utcOffsetMinutes,
+        )
+    }
+
+    private fun partnerIndexToDay(index: Int): RuleCalendar.Type.Weekly.Day =
+        when (index) {
+            0 -> RuleCalendar.Type.Weekly.Day.MONDAY
+            1 -> RuleCalendar.Type.Weekly.Day.TUESDAY
+            2 -> RuleCalendar.Type.Weekly.Day.WEDNESDAY
+            3 -> RuleCalendar.Type.Weekly.Day.THURSDAY
+            4 -> RuleCalendar.Type.Weekly.Day.FRIDAY
+            5 -> RuleCalendar.Type.Weekly.Day.SATURDAY
+            else -> RuleCalendar.Type.Weekly.Day.SUNDAY
+        }
+
+    private fun dayToPartnerIndex(day: RuleCalendar.Type.Weekly.Day): Int =
+        when (day) {
+            RuleCalendar.Type.Weekly.Day.MONDAY -> 0
+            RuleCalendar.Type.Weekly.Day.TUESDAY -> 1
+            RuleCalendar.Type.Weekly.Day.WEDNESDAY -> 2
+            RuleCalendar.Type.Weekly.Day.THURSDAY -> 3
+            RuleCalendar.Type.Weekly.Day.FRIDAY -> 4
+            RuleCalendar.Type.Weekly.Day.SATURDAY -> 5
+            RuleCalendar.Type.Weekly.Day.SUNDAY -> 6
+        }
+}

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

@@ -0,0 +1,168 @@
+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
+import pl.efento.mobile.bluetooth.model.sensor.Rule
+import pl.efento.mobile.bluetooth.model.sensor.RuleCalendar
+import pl.efento.mobile.bluetooth.model.sensor.SensorConfiguration
+
+/**
+ * Internal adapter to the sensor BLE runtime. Keep vendor types inside this file.
+ */
+internal object SensorBleRuntime {
+    private val initMonitor = Any()
+    @Volatile private var initialized = false
+
+    fun initialize(application: Application) {
+        if (initialized) return
+        synchronized(initMonitor) {
+            if (initialized) return
+            EfentoBluetooth.init(application)
+            initialized = true
+        }
+    }
+
+    fun mapError(e: Throwable): TempivoSensorException {
+        if (e is TempivoSensorException) return e
+        val className = e.javaClass.name
+        return when {
+            e is InvalidResetCodeException || className.contains("InvalidResetCode") ->
+                TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "Invalid PIN.", e)
+            e is UnsupportedCommandException || className.contains("UnsupportedCommand") ->
+                TempivoSensorException(TempivoSensorException.Code.UNSUPPORTED_COMMAND, "Unsupported command.", e)
+            className.contains("NotConnected") ->
+                TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.", e)
+            else ->
+                TempivoSensorException(TempivoSensorException.Code.UNKNOWN, "Sensor request failed.", e)
+        }
+    }
+
+    suspend fun connect(
+        application: Application,
+        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)
+        }
+    }
+
+    suspend fun disconnect(session: Session?) {
+        when (session) {
+            is Session.Modern -> runCatching { session.connection.disconnect() }
+            is Session.Legacy -> runCatching { session.connection.disconnect() }
+            null -> Unit
+        }
+    }
+
+    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 writeRules(session: Session, rules: List<Rule>, calendars: List<RuleCalendar>) {
+        when (session) {
+            is Session.Modern -> {
+                val base = modernGetConfiguration(session.connection)
+                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.",
+                )
+        }
+    }
+
+    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)
+                }
+            }
+        }
+    }
+
+    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)
+        }
+    }
+
+    fun compileRules(cfg: TempivoSensorConfiguration): Pair<List<Rule>, List<RuleCalendar>> =
+        PartnerBleRules.compile(cfg)
+
+    fun decompile(cfg: SensorConfiguration): TempivoSensorConfiguration =
+        PartnerBleRules.decompile(cfg)
+
+    private suspend fun modernGetConfiguration(modern: SensorConnection): SensorConfiguration {
+        var last: Exception? = null
+        repeat(3) { attempt ->
+            try {
+                if (attempt > 0) {
+                    runCatching { modern.commands.getDeviceInfo { } }
+                }
+                return modern.commands.getConfiguration { }
+            } catch (e: Exception) {
+                last = e
+                if (attempt < 2) delay(400)
+            }
+        }
+        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()
+    }
+}

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

@@ -155,8 +155,7 @@ object TempivoSensorBeaconDecoder {
         var measurementCounter: Long? = null
         var readingTimestampUnix: Long? = null
         var readingTimestampIso: String? = null
-        var periodBaseSeconds: Int? = null
-        var periodFactor: Int? = null
+        var measurementIntervalSeconds: Int? = null
         val readings = mutableListOf<TempivoSensorBeaconReading>()
 
         if (adv03 != null && adv03.isNotEmpty()) {
@@ -170,8 +169,7 @@ object TempivoSensorBeaconDecoder {
                     measurementCounter = parsed.measurementCounter
                     readingTimestampUnix = parsed.readingTimestampUnix
                     readingTimestampIso = parsed.readingTimestampIso
-                    periodBaseSeconds = parsed.periodBaseSeconds
-                    periodFactor = parsed.periodFactor
+                    measurementIntervalSeconds = parsed.measurementIntervalSeconds
                 }
                 0x02 -> {
                     val fw5 = fw5Summary(adv03)
@@ -233,26 +231,13 @@ object TempivoSensorBeaconDecoder {
             measurementCounter = measurementCounter,
             readingTimestampUnix = readingTimestampUnix,
             readingTimestampIso = readingTimestampIso,
-            periodBaseSeconds = periodBaseSeconds,
-            periodFactor = periodFactor,
+            measurementIntervalSeconds = measurementIntervalSeconds,
             readings = readings,
             readingsCount = readingsCount,
             summary = sumOut.ifEmpty { null },
         )
     }
 
-    /** Firmware 7+ → modern (`false`); older families → legacy (`true`). */
-    fun legacyHintFromFirmware(firmware: String?): Boolean? {
-        if (firmware.isNullOrBlank()) return null
-        val t = firmware.trim()
-        if (t.startsWith("FW 5", ignoreCase = true)) return true
-        val m = Regex("""^(\d+)\.\d+""").find(t) ?: return null
-        val major = m.groupValues[1].toIntOrNull() ?: return null
-        if (major >= 7) return false
-        if (major >= 1) return true
-        return null
-    }
-
     private data class Adv03Parsed(
         val firmware: String?,
         val batteryOk: Boolean?,
@@ -261,8 +246,7 @@ object TempivoSensorBeaconDecoder {
         val measurementCounter: Long?,
         val readingTimestampUnix: Long?,
         val readingTimestampIso: String?,
-        val periodBaseSeconds: Int?,
-        val periodFactor: Int?,
+        val measurementIntervalSeconds: Int?,
     )
 
     private fun fw5Summary(frame: ByteArray): String? {
@@ -360,7 +344,7 @@ object TempivoSensorBeaconDecoder {
 
     private fun parseFw6Adv03(adv03: ByteArray): Adv03Parsed {
         if (adv03.size < ADV_FRAME_03_LEN) {
-            return Adv03Parsed(null, null, null, null, null, null, null, null, null)
+            return Adv03Parsed(null, null, null, null, null, null, null, null)
         }
         val fwRaw = ((adv03[7].toInt() and 0xFF) shl 8) or (adv03[8].toInt() and 0xFF)
         val major = (fwRaw shr 11) and 0x1F
@@ -399,8 +383,7 @@ object TempivoSensorBeaconDecoder {
             measurementCounter = measurementCounter,
             readingTimestampUnix = readingTimestampUnix,
             readingTimestampIso = readingTimestampIso,
-            periodBaseSeconds = pbase,
-            periodFactor = pfact,
+            measurementIntervalSeconds = pbase * pfact,
         )
     }
 }

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

@@ -118,7 +118,6 @@ class TempivoSensorBeaconScanner(
         val summary =
             telemetry?.summary?.takeIf { it.isNotEmpty() }
                 ?: serial
-        val legacyHint = TempivoSensorBeaconDecoder.legacyHintFromFirmware(telemetry?.firmware)
         return TempivoSensorBeaconDevice(
             deviceId = addr,
             bluetoothMacAddress = macColons,
@@ -126,7 +125,6 @@ class TempivoSensorBeaconScanner(
             rssi = result.rssi,
             telemetry = telemetry,
             summary = summary,
-            legacyHint = legacyHint,
         )
     }