@tempivo/sensor-beacon 0.1.0 → 0.2.0

package/android/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/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()
+    }
+}