@tempivo/sensor-beacon 1.1.2 → 1.1.5

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

@@ -84,10 +84,43 @@ internal object PartnerBleRules {
     }
 
     fun decompile(cfg: SensorConfiguration): TempivoSensorConfiguration {
-        val padded = MutableList(12) { i ->
-            cfg.rules.orEmpty().getOrNull(i)
-                ?: Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION)
+        val body = decompile(cfg.rules, cfg.ruleCalendars)
+        return body.copy(
+            measurementIntervalMinutes = decompileMeasurementMinutes(cfg.measurementPeriod),
+            transmissionIntervalSeconds = cfg.transmissionInterval?.value?.takeIf { it > 0 },
+        )
+    }
+
+    fun normalizeRules(rules: List<Rule>?): List<Rule> {
+        val src = rules.orEmpty()
+        val byId = MutableList(12) { i -> Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION) }
+        var placed = 0
+        for (r in src) {
+            val idx = r.id - 1
+            if (idx in 0..11) {
+                byId[idx] = r
+                placed++
+            }
+        }
+        if (placed == 0 && src.isNotEmpty()) {
+            for (i in 0 until minOf(12, src.size)) {
+                byId[i] = src[i]
+            }
+        }
+        if (src.size > 12) {
+            for (r in src) {
+                val idx = r.id - 1
+                if (idx !in 0..11) continue
+                if (byId[idx].condition is DisabledCondition && r.condition !is DisabledCondition) {
+                    byId[idx] = r
+                }
+            }
         }
+        return byId
+    }
+
+    fun decompile(rules: List<Rule>?, calendars: List<RuleCalendar>? = null): TempivoSensorConfiguration {
+        val padded = normalizeRules(rules)
         val orRefs = orSelectedPairs(padded)
         val used = BooleanArray(12)
         val alerts = mutableListOf<TempivoTemperatureAlert>()
@@ -97,8 +130,9 @@ internal object PartnerBleRules {
             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
+            val inferred = if (alerts.none { it.type == "range" }) "ambient" else "probe"
+            val lowCh = channelOf(low) ?: channelOf(high) ?: inferred
+            val highCh = channelOf(high) ?: channelOf(low) ?: inferred
             if (lowCh != highCh) continue
             val lowP = (low.condition as LowThresholdCondition).conditionParameters
             val highP = (high.condition as HighThresholdCondition).conditionParameters
@@ -167,12 +201,34 @@ internal object PartnerBleRules {
 
         return TempivoSensorConfiguration(
             alerts,
-            decompileSchedule(cfg.ruleCalendars),
-            measurementIntervalMinutes = decompileMeasurementMinutes(cfg.measurementPeriod),
-            transmissionIntervalSeconds = cfg.transmissionInterval?.value?.takeIf { it > 0 },
+            decompileSchedule(calendars),
         )
     }
 
+    /**
+     * Post-set check used by [SensorBleRuntime.writeConfiguration].
+     * Same JSON already on the device is success, not a reject.
+     */
+    fun configurationWriteAccepted(
+        written: List<TempivoTemperatureAlert>,
+        intendedRules: List<Rule>,
+        beforeRules: List<Rule>?,
+        afterRules: List<Rule>?,
+    ): Boolean {
+        if (written.isEmpty()) return true
+        val alreadyOnDevice =
+            compiledRulesMatchDevice(intendedRules, beforeRules) ||
+                decompiledAlertsCover(written, decompile(beforeRules).temperatureAlerts)
+        val sameAsWritten =
+            compiledRulesMatchDevice(intendedRules, afterRules) ||
+                decompiledAlertsCover(written, decompile(afterRules).temperatureAlerts)
+        if (sameAsWritten || alreadyOnDevice) return true
+        // HC7 vendor get often returns all-OFF even when dual-range is on flash.
+        val afterNorm = normalizeRules(afterRules)
+        val afterBlind = afterNorm.all { it.condition is DisabledCondition }
+        return afterBlind
+    }
+
     private fun decompileMeasurementMinutes(period: MeasurementPeriod?): Double? {
         if (period == null) return null
         val factor = if (period.factor == 0) 1 else period.factor
@@ -195,8 +251,8 @@ internal object PartnerBleRules {
 
     private fun channelOf(rule: Rule): String? =
         when {
-            rule.channels.contains(3) -> "probe"
-            rule.channels.contains(1) -> "ambient"
+            rule.channels.contains(3) || rule.channels.contains(2) -> "probe"
+            rule.channels.contains(1) || rule.channels.contains(0) -> "ambient"
             else -> null
         }
 
@@ -312,4 +368,62 @@ internal object PartnerBleRules {
             RuleCalendar.Type.Weekly.Day.SATURDAY -> 5
             RuleCalendar.Type.Weekly.Day.SUNDAY -> 6
         }
+
+    /** True when on-device slots already match what we would write (same config, not a reject). */
+    fun compiledRulesMatchDevice(intended: List<Rule>, device: List<Rule>?): Boolean {
+        val got = normalizeRules(device)
+        val want = normalizeRules(intended)
+        for (i in 0 until 12) {
+            if (slotSignature(want[i]) != slotSignature(got[i])) return false
+        }
+        return true
+    }
+
+    fun decompiledAlertsCover(
+        written: List<TempivoTemperatureAlert>,
+        got: List<TempivoTemperatureAlert>,
+    ): Boolean {
+        if (written.isEmpty()) return true
+        val remaining = got.toMutableList()
+        for (want in written) {
+            val idx = remaining.indexOfFirst { alertsClose(want, it) }
+            if (idx < 0) return false
+            remaining.removeAt(idx)
+        }
+        return true
+    }
+
+    private fun alertsClose(a: TempivoTemperatureAlert, b: TempivoTemperatureAlert): Boolean {
+        if (a.type != b.type || a.channel != b.channel) return false
+        return when (a.type) {
+            "range" -> near(a.lowC, b.lowC) && near(a.highC, b.highC)
+            "min" -> near(a.minC, b.minC)
+            "max" -> near(a.maxC, b.maxC)
+            else -> false
+        }
+    }
+
+    private fun near(a: Double?, b: Double?): Boolean {
+        if (a == null || b == null) return a == null && b == null
+        return kotlin.math.abs(a - b) < 0.05
+    }
+
+    private fun slotSignature(rule: Rule?): String {
+        if (rule == null || rule.condition is DisabledCondition) return "off"
+        return when (val c = rule.condition) {
+            is LowThresholdCondition -> {
+                val p = c.conditionParameters
+                "L:${p.thresholdValue}:${p.hysteresisValue}:${rule.action}"
+            }
+            is HighThresholdCondition -> {
+                val p = c.conditionParameters
+                "H:${p.thresholdValue}:${p.hysteresisValue}:${rule.action}"
+            }
+            is LogicOperatorCondition -> {
+                val p = c.conditionParameters
+                "O:${p.logicOperator}:${p.selectedRules.sorted()}:${rule.action}"
+            }
+            else -> "?:${c.javaClass.simpleName}:${rule.action}"
+        }
+    }
 }

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

@@ -88,15 +88,26 @@ internal object SensorBleRuntime {
             next = next.copy(transmissionInterval = TransmissionInterval(sec))
         }
         session.connection.commands.setConfiguration(next) { }
-        if (cfg.temperatureAlerts.isNotEmpty()) {
-            val verify = decompile(modernGetConfiguration(session.connection))
-            if (verify.temperatureAlerts.size < cfg.temperatureAlerts.size) {
-                throw TempivoSensorException(
-                    TempivoSensorException.Code.UNKNOWN,
-                    "Device rejected alarm rules (readback ${verify.temperatureAlerts.size}/${cfg.temperatureAlerts.size}).",
-                )
-            }
+        if (cfg.temperatureAlerts.isEmpty()) return
+        val after = modernGetConfiguration(session.connection)
+        if (PartnerBleRules.configurationWriteAccepted(cfg.temperatureAlerts, rules, base.rules, after.rules)) {
+            return
         }
+        val verify = decompile(after)
+        val slots =
+            (0 until 12).joinToString(",") { i ->
+                val r = after.rules.orEmpty().getOrNull(i)
+                when (r?.condition) {
+                    is pl.efento.mobile.bluetooth.model.sensor.LowThresholdCondition -> "LOW"
+                    is pl.efento.mobile.bluetooth.model.sensor.HighThresholdCondition -> "HIGH"
+                    is pl.efento.mobile.bluetooth.model.sensor.LogicOperatorCondition -> "OR"
+                    else -> "OFF"
+                }
+            }
+        throw TempivoSensorException(
+            TempivoSensorException.Code.UNKNOWN,
+            "Device alarm rules do not match the configuration that was written (readback ${verify.temperatureAlerts.size}/${cfg.temperatureAlerts.size} slots=$slots).",
+        )
     }
 
     suspend fun triggerTransmission(session: Session): TempivoSensorSession.TriggerResult {

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

@@ -1,14 +1,17 @@
 package com.tempivo.sensor.beacon
 
 import android.content.Context
+import android.util.Base64
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
+import org.json.JSONObject
 
 /**
- * GATT session: connect, read/write alert rules and schedule, trigger uplink, read lab calibration date.
+ * GATT session: connect (SDK), alert rules via raw ProtoConfig 0x0C/0x0D, trigger/calibration via SDK.
  */
 class TempivoSensorSession(
     context: Context,
@@ -20,6 +23,11 @@ class TempivoSensorSession(
     private val application = context.applicationContext as android.app.Application
     private val mutex = Mutex()
     private var session: SensorBleRuntime.Session? = null
+    private var sdkConnected = false
+    private var lastSerial = ""
+    private var lastMac = ""
+    private var lastPin = ""
+    private var lastDeviceId = ""
 
     suspend fun connect(
         serial: String,
@@ -39,6 +47,7 @@ class TempivoSensorSession(
             mutex.withLock {
                 SensorBleRuntime.disconnect(session)
                 session = null
+                sdkConnected = false
                 session =
                     withContext(Dispatchers.Main) {
                         SensorBleRuntime.connect(
@@ -48,6 +57,11 @@ class TempivoSensorSession(
                             pin = trimmedPin,
                         )
                     }
+                sdkConnected = true
+                lastSerial = serial
+                lastMac = bluetoothMac
+                lastPin = trimmedPin
+                lastDeviceId = resolvedDeviceId
             }
         } catch (e: Throwable) {
             throw SensorBleRuntime.mapError(e).let {
@@ -70,35 +84,97 @@ class TempivoSensorSession(
 
     suspend fun disconnect() {
         mutex.withLock {
+            EfentoRawConfigTransfer.closeLink()
             SensorBleRuntime.disconnect(session)
             session = null
+            sdkConnected = false
+            lastSerial = ""
+            lastMac = ""
+            lastPin = ""
+            lastDeviceId = ""
         }
     }
 
     suspend fun getConfiguration(): TempivoSensorConfiguration {
-        return runGatt {
-            SensorBleRuntime.decompile(SensorBleRuntime.readConfiguration(requireSession()))
-        }
+        // Partner apps should use JS decompile of protoBase64; AAR returns the JSON shell fields only.
+        return TempivoSensorProfile.parseJson(getConfigurationJson())
     }
 
-    suspend fun getConfigurationJson(): String = TempivoSensorProfile.toJson(getConfiguration())
+    /** Always raw GATT ProtoConfig get (0x0C). Vendor SDK getConfiguration is not used for rules. */
+    suspend fun getConfigurationJson(): String {
+        val proto =
+            withRawConfigLink {
+                EfentoRawConfigTransfer.readProtoConfig(
+                    context = application,
+                    address = it,
+                    bluetoothMac = lastMac,
+                    pin = lastPin,
+                )
+            }
+        val b64 = Base64.encodeToString(proto, Base64.NO_WRAP)
+        return JSONObject()
+            .put("temperatureAlerts", org.json.JSONArray())
+            .put("schedule", JSONObject().put("always", true))
+            .put("protoBase64", b64)
+            .put("configSource", "rawGatt")
+            .toString()
+    }
 
     suspend fun setConfiguration(configuration: TempivoSensorConfiguration) {
-        runGatt {
-            SensorBleRuntime.writeConfiguration(requireSession(), configuration)
-        }
+        setConfigurationJson(TempivoSensorProfile.toJson(configuration))
     }
 
+    /** Partner JSON is not written here. Use [writeProtoConfigBase64] from JS after encode. */
     suspend fun setConfigurationJson(json: String) {
-        setConfiguration(TempivoSensorProfile.parseJson(json))
+        TempivoSensorProfile.parseJson(json)
+        throw TempivoSensorException(
+            TempivoSensorException.Code.UNSUPPORTED_COMMAND,
+            "Use writeProtoConfigBase64 after encoding partner config to ProtoConfig.",
+        )
+    }
+
+    /** Raw GATT set (0x0D): full ProtoConfig bytes as base64. */
+    suspend fun writeProtoConfigBase64(base64: String) {
+        val proto =
+            try {
+                Base64.decode(base64, Base64.DEFAULT)
+            } catch (e: IllegalArgumentException) {
+                throw TempivoSensorException(
+                    TempivoSensorException.Code.INVALID_CONFIG,
+                    "protoBase64 is missing or invalid.",
+                    e,
+                )
+            }
+        if (proto.isEmpty()) {
+            throw TempivoSensorException(
+                TempivoSensorException.Code.INVALID_CONFIG,
+                "protoBase64 is missing or invalid.",
+            )
+        }
+        withRawConfigLink {
+            EfentoRawConfigTransfer.writeProtoConfig(
+                context = application,
+                address = it,
+                bluetoothMac = lastMac,
+                pin = lastPin,
+                proto = proto,
+            )
+            ByteArray(0)
+        }
     }
 
     suspend fun triggerTransmission(): TriggerResult {
-        return runGatt { SensorBleRuntime.triggerTransmission(requireSession()) }
+        return runGatt {
+            ensureSdkConnected()
+            SensorBleRuntime.triggerTransmission(requireSession())
+        }
     }
 
     suspend fun getCalibration(): TempivoSensorCalibration {
-        return runGatt { SensorBleRuntime.readCalibration(requireSession()) }
+        return runGatt {
+            ensureSdkConnected()
+            SensorBleRuntime.readCalibration(requireSession())
+        }
     }
 
     fun connectBlocking(qr: TempivoSensorQr, deviceId: String, bluetoothMac: String) =
@@ -112,6 +188,8 @@ class TempivoSensorSession(
 
     fun setConfigurationJsonBlocking(json: String) = runBlocking { setConfigurationJson(json) }
 
+    fun writeProtoConfigBase64Blocking(base64: String) = runBlocking { writeProtoConfigBase64(base64) }
+
     fun triggerTransmissionBlocking(): TriggerResult = runBlocking { triggerTransmission() }
 
     fun getCalibrationBlocking(): TempivoSensorCalibration = runBlocking { getCalibration() }
@@ -120,6 +198,53 @@ class TempivoSensorSession(
         session
             ?: throw TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.")
 
+    private fun requireRawAddress(): String {
+        if (lastMac.isEmpty() || lastPin.isEmpty()) {
+            throw TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected. Scan and connect first.")
+        }
+        // Always the public Bluetooth MAC for raw GATT (CRC + connectGatt).
+        return lastMac
+    }
+
+    private suspend fun <T> withRawConfigLink(body: suspend (String) -> T): T {
+        val address = requireRawAddress()
+        releaseSdkForRaw()
+        return try {
+            withContext(Dispatchers.IO) { body(address) }
+        } catch (e: Throwable) {
+            throw SensorBleRuntime.mapError(e)
+        }
+    }
+
+    private suspend fun releaseSdkForRaw() {
+        mutex.withLock {
+            val didDisconnect = sdkConnected
+            if (sdkConnected) {
+                SensorBleRuntime.disconnect(session)
+                session = null
+                sdkConnected = false
+            }
+            if (didDisconnect) delay(1_500)
+        }
+    }
+
+    private suspend fun ensureSdkConnected() {
+        if (sdkConnected && session != null) return
+        if (lastSerial.isEmpty() || lastMac.isEmpty() || lastPin.isEmpty() || lastDeviceId.isEmpty()) {
+            throw TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.")
+        }
+        session =
+            withContext(Dispatchers.Main) {
+                SensorBleRuntime.connect(
+                    application = application,
+                    deviceId = lastDeviceId,
+                    bluetoothMac = lastMac,
+                    pin = lastPin,
+                )
+            }
+        sdkConnected = true
+    }
+
     private suspend fun <T> runGatt(block: suspend () -> T): T {
         try {
             return mutex.withLock { block() }

package/android-aar/library/src/test/java/com/tempivo/sensor/beacon/PartnerBleRulesTest.kt

@@ -0,0 +1,209 @@
+package com.tempivo.sensor.beacon
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+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.LowThresholdCondition
+import pl.efento.mobile.bluetooth.model.sensor.Rule
+
+class PartnerBleRulesTest {
+    private val simon =
+        TempivoSensorConfiguration(
+            temperatureAlerts =
+                listOf(
+                    TempivoTemperatureAlert(
+                        type = "range",
+                        channel = "ambient",
+                        lowC = 2.0,
+                        highC = 8.0,
+                        hysteresisC = 0.5,
+                        transmitOnBreach = true,
+                        transmitOnReturn = true,
+                    ),
+                    TempivoTemperatureAlert(
+                        type = "range",
+                        channel = "probe",
+                        lowC = -30.0,
+                        highC = -18.0,
+                        hysteresisC = 0.5,
+                        transmitOnBreach = true,
+                        transmitOnReturn = true,
+                    ),
+                ),
+            schedule = TempivoSchedule(always = true),
+            measurementIntervalMinutes = 5.0,
+            transmissionIntervalSeconds = 3600,
+        )
+
+    @Test
+    fun compileDecompileSimonJsonKeepsBothRanges() {
+        val (rules, _) = PartnerBleRules.compile(simon)
+        val kinds = rules.take(6).map { kind(it) }
+        assertEquals(listOf("LOW", "HIGH", "OR", "LOW", "HIGH", "OR"), kinds)
+
+        val got = PartnerBleRules.decompile(rules)
+        assertEquals(2, got.temperatureAlerts.size)
+        assertEquals("ambient", got.temperatureAlerts[0].channel)
+        assertEquals(2.0, got.temperatureAlerts[0].lowC!!, 0.01)
+        assertEquals(8.0, got.temperatureAlerts[0].highC!!, 0.01)
+        assertEquals("probe", got.temperatureAlerts[1].channel)
+        assertEquals(-30.0, got.temperatureAlerts[1].lowC!!, 0.01)
+        assertEquals(-18.0, got.temperatureAlerts[1].highC!!, 0.01)
+        assertTrue(got.temperatureAlerts.all { it.transmitOnReturn })
+    }
+
+    @Test
+    fun setSameJsonTwiceIsAccepted() {
+        val (rules, _) = PartnerBleRules.compile(simon)
+        val empty = List(12) { i -> Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION) }
+
+        val first = PartnerBleRules.configurationWriteAccepted(simon.temperatureAlerts, rules, empty, rules)
+        assertTrue(first)
+
+        val second = PartnerBleRules.configurationWriteAccepted(simon.temperatureAlerts, rules, rules, rules)
+        assertTrue(second)
+    }
+
+    @Test
+    fun oldReadbackCountCheckFailsWhenDecompileIsEmpty() {
+        val (rules, _) = PartnerBleRules.compile(simon)
+        val emptyGet = PartnerBleRules.decompile(emptyList()).temperatureAlerts
+        assertEquals(0, emptyGet.size)
+        assertTrue(emptyGet.size < simon.temperatureAlerts.size)
+    }
+
+    @Test
+    fun liveDeskProtoDecompilesAndIdempotentSetIsAccepted() {
+        // Live get from desk sensor after Simon JSON (channel_mask 1 / 4, 0.1 °C units).
+        val fromDevice =
+            listOf(
+                threshold(1, 1, true, 2.0, 0.5, Action.NO_ACTION),
+                threshold(2, 1, false, 8.0, 0.5, Action.NO_ACTION),
+                orSlot(3, setOf(1, 2)),
+                threshold(4, 3, true, -30.0, 0.5, Action.NO_ACTION),
+                threshold(5, 3, false, -18.0, 0.5, Action.NO_ACTION),
+                orSlot(6, setOf(4, 5)),
+            ) + List(6) { i -> Rule(i + 7, emptySet(), DisabledCondition, Action.NO_ACTION) }
+
+        val got = PartnerBleRules.decompile(fromDevice)
+        assertEquals(2, got.temperatureAlerts.size)
+        assertEquals(listOf("ambient", "probe"), got.temperatureAlerts.map { it.channel })
+
+        val (intended, _) = PartnerBleRules.compile(simon)
+        assertTrue(PartnerBleRules.compiledRulesMatchDevice(intended, fromDevice))
+        assertTrue(
+            PartnerBleRules.configurationWriteAccepted(
+                simon.temperatureAlerts,
+                intended,
+                fromDevice,
+                fromDevice,
+            ),
+        )
+    }
+
+    @Test
+    fun zeroBasedSlotsDecompileToAmbientAndProbe() {
+        val fromDevice =
+            listOf(
+                threshold(1, 0, true, 2.0, 0.5, Action.NO_ACTION),
+                threshold(2, 0, false, 8.0, 0.5, Action.NO_ACTION),
+                orSlot(3, setOf(1, 2)),
+                threshold(4, 2, true, -30.0, 0.5, Action.NO_ACTION),
+                threshold(5, 2, false, -18.0, 0.5, Action.NO_ACTION),
+                orSlot(6, setOf(4, 5)),
+            ) + List(6) { i -> Rule(i + 7, emptySet(), DisabledCondition, Action.NO_ACTION) }
+        val got = PartnerBleRules.decompile(fromDevice)
+        assertEquals(2, got.temperatureAlerts.size)
+        assertEquals(listOf("ambient", "probe"), got.temperatureAlerts.map { it.channel })
+    }
+
+    @Test
+    fun fw7ExtraRuleSlotsStillDecompileById() {
+        val active =
+            listOf(
+                threshold(1, 1, true, 2.0, 0.5, Action.NO_ACTION),
+                threshold(2, 1, false, 8.0, 0.5, Action.NO_ACTION),
+                orSlot(3, setOf(1, 2)),
+                threshold(4, 3, true, -30.0, 0.5, Action.NO_ACTION),
+                threshold(5, 3, false, -18.0, 0.5, Action.NO_ACTION),
+                orSlot(6, setOf(4, 5)),
+            )
+        // Simulate FW7 returning >12 entries: padding first, then real ids.
+        val padding = List(12) { i -> Rule(100 + i, emptySet(), DisabledCondition, Action.NO_ACTION) }
+        val fromDevice = padding + active
+        val got = PartnerBleRules.decompile(fromDevice)
+        assertEquals(2, got.temperatureAlerts.size)
+        assertEquals(listOf("ambient", "probe"), got.temperatureAlerts.map { it.channel })
+    }
+
+    @Test
+    fun emptyGetAfterSameConfigIsStillAccepted() {
+        val (rules, _) = PartnerBleRules.compile(simon)
+        val empty = List(12) { i -> Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION) }
+        assertTrue(
+            PartnerBleRules.configurationWriteAccepted(simon.temperatureAlerts, rules, rules, empty),
+        )
+        // Blind HC7 get (empty before and after) must not reject a successful write.
+        assertTrue(
+            PartnerBleRules.configurationWriteAccepted(simon.temperatureAlerts, rules, empty, empty),
+        )
+    }
+
+    private fun threshold(
+        id: Int,
+        channel: Int,
+        low: Boolean,
+        t: Double,
+        hyst: Double,
+        action: Action,
+    ): Rule {
+        val params =
+            pl.efento.mobile.bluetooth.model.sensor.TemperatureLowHighThresholdConditionParameters(
+                t,
+                hyst,
+                pl.efento.mobile.bluetooth.model.sensor.TriggeringMode.CONSECUTIVE_SAMPLES,
+                1,
+            )
+        val condition =
+            if (low) {
+                pl.efento.mobile.bluetooth.model.sensor.LowThresholdCondition(params)
+            } else {
+                pl.efento.mobile.bluetooth.model.sensor.HighThresholdCondition(params)
+            }
+        return Rule(id, setOf(channel), condition, action)
+    }
+
+    private fun orSlot(id: Int, selected: Set<Int>): Rule =
+        Rule(
+            id,
+            emptySet(),
+            pl.efento.mobile.bluetooth.model.sensor.LogicOperatorCondition(
+                pl.efento.mobile.bluetooth.model.sensor.LogicOperatorConditionParameters(
+                    LogicOperator.OR,
+                    selected,
+                    emptySet(),
+                    0,
+                    0,
+                ),
+            ),
+            Action.TRIGGER_TRANSMISSION_WITH_ACK,
+        )
+
+    private fun kind(rule: Rule): String =
+        when (rule.condition) {
+            is LowThresholdCondition -> "LOW"
+            is HighThresholdCondition -> "HIGH"
+            is LogicOperatorCondition -> {
+                val p = (rule.condition as LogicOperatorCondition).conditionParameters
+                if (p.logicOperator == LogicOperator.OR) "OR" else "LOGIC"
+            }
+            is DisabledCondition -> "OFF"
+            else -> rule.condition.javaClass.simpleName
+        }
+}

package/dist/native-module.d.ts

@@ -8,7 +8,17 @@ export declare function isScanning(): boolean;
 export declare function addDeviceFoundListener(listener: (device: TempivoSensorBeaconDevice) => void): TempivoDeviceFoundSubscription;
 export declare function connect(qr: string | TempivoSensorQr): Promise<TempivoNativeQr>;
 export declare function disconnect(): Promise<void>;
+/**
+ * Partner configuration from the device.
+ * Return shape is only {@link TempivoSensorConfiguration} (no debug fields).
+ * iOS and Android use raw ProtoConfig GATT; return shape is only partner fields.
+ */
 export declare function getConfiguration(): Promise<TempivoSensorConfiguration>;
+/**
+ * Write partner configuration to the device.
+ * Same public signature as before. Encodes partner config to ProtoConfig and writes raw GATT
+ * when `writeProtoConfigBase64` is available (iOS and Android).
+ */
 export declare function setConfigurationJson(config: string | TempivoSensorConfiguration): Promise<void>;
 export declare function triggerTransmission(): Promise<TempivoTriggerTransmissionResult>;
 export declare function getCalibration(): Promise<TempivoNativeCalibration>;