@tempivo/sensor-beacon 0.1.0 → 0.1.1

package/android/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorBeaconDecoder.kt

@@ -0,0 +1,406 @@
+package com.tempivo.sensor.beacon
+
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+import kotlin.math.abs
+import kotlin.math.floor
+
+/**
+ * Decodes Tempivo sensor BLE manufacturer data (adv frame `0x03` + scan response `0x04`).
+ *
+ * Android [android.bluetooth.le.ScanRecord.getManufacturerSpecificData] returns the payload **after**
+ * the 2-byte company id — i.e. starts with `0x03` / `0x04`, not `6C 02`.
+ */
+object TempivoSensorBeaconDecoder {
+
+    /** Bluetooth SIG company identifier (little-endian on air: `6C 02`). */
+    const val MANUFACTURER_COMPANY_ID: Int = 0x026C
+
+    const val ADV_FRAME_03_LEN = 22
+
+    private data class MeasureSpec(
+        val name: String,
+        val resolution: Double,
+        val metaFactor: Int,
+        val continuous: Boolean,
+    )
+
+    private val measureTypes: Map<Int, MeasureSpec> =
+        mapOf(
+            0x01 to MeasureSpec("Temperature", 0.1, 1, true),
+            0x02 to MeasureSpec("Humidity", 1.0, 1, true),
+            0x03 to MeasureSpec("Atmospheric pressure", 0.1, 1, true),
+            0x04 to MeasureSpec("Differential pressure", 1.0, 1, true),
+            0x05 to MeasureSpec("OK/Alarm", 1.0, 1, false),
+            0x06 to MeasureSpec("IAQ", 1.0, 3, true),
+            0x07 to MeasureSpec("Flooding", 1.0, 1, false),
+            0x08 to MeasureSpec("Pulse count", 1.0, 1, true),
+            0x09 to MeasureSpec("Electricity meter", 1.0, 1, true),
+            0x0A to MeasureSpec("Water meter", 1.0, 1, true),
+            0x0B to MeasureSpec("Soil moisture", 1.0, 1, true),
+            0x0C to MeasureSpec("CO", 1.0, 1, true),
+            0x0D to MeasureSpec("NO₂", 1.0, 1, true),
+            0x0E to MeasureSpec("H₂S", 0.01, 1, true),
+            0x0F to MeasureSpec("Ambient light", 0.1, 1, true),
+            0x10 to MeasureSpec("PM1.0", 1.0, 1, true),
+            0x11 to MeasureSpec("PM2.5", 1.0, 1, true),
+            0x12 to MeasureSpec("PM10", 1.0, 1, true),
+            0x13 to MeasureSpec("Noise", 0.1, 1, true),
+            0x14 to MeasureSpec("NH₃", 1.0, 1, true),
+            0x15 to MeasureSpec("CH₄", 1.0, 1, true),
+            0x16 to MeasureSpec("High pressure", 1.0, 1, true),
+            0x17 to MeasureSpec("Distance", 1.0, 1, true),
+            0x1A to MeasureSpec("CO₂", 1.0, 3, true),
+            0x1B to MeasureSpec("Humidity", 0.1, 1, true),
+            0x1C to MeasureSpec("Static IAQ", 1.0, 3, true),
+            0x1D to MeasureSpec("CO₂ equivalent", 1.0, 3, true),
+            0x1E to MeasureSpec("Breath VOC", 1.0, 3, true),
+            0x20 to MeasureSpec("Percentage", 0.01, 1, true),
+            0x21 to MeasureSpec("Voltage", 0.1, 1, true),
+            0x22 to MeasureSpec("Current", 0.01, 1, true),
+        )
+
+    /** 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
+        return buildString(12) {
+            for (i in 1..6) {
+                append(String.format(Locale.US, "%02X", frame[i].toInt() and 0xFF))
+            }
+        }
+    }
+
+    fun macKey(macWithColons: String): String =
+        macWithColons.replace(":", "", ignoreCase = true).uppercase(Locale.US)
+
+    fun lookupKeys(primaryMacKey: String, extraSerialKey: String? = null): List<String> {
+        val keys = linkedSetOf(primaryMacKey.uppercase(Locale.US))
+        if (!extraSerialKey.isNullOrBlank()) keys.add(extraSerialKey.uppercase(Locale.US))
+        return keys.toList()
+    }
+
+    /**
+     * @return true if any `0x03` / `0x04` frame was stored.
+     */
+    fun ingestManufacturerPayload(
+        data: ByteArray,
+        primaryMacKey: String,
+        last03: MutableMap<String, ByteArray>,
+        last04: MutableMap<String, ByteArray>,
+    ): Boolean {
+        var changed = false
+        val frames = splitFrames(data)
+        for (fr in frames) {
+            if (fr.isEmpty()) continue
+            val tag = fr[0].toInt() and 0xFF
+            when (tag) {
+                0x03 ->
+                    if (fr.size >= ADV_FRAME_03_LEN) {
+                        val frame = fr.copyOf(ADV_FRAME_03_LEN)
+                        val keys = lookupKeys(primaryMacKey, serialKeyFromAdv03(frame))
+                        for (key in keys) {
+                            if (last03[key] != frame) {
+                                last03[key] = frame
+                                changed = true
+                            }
+                        }
+                    }
+                0x02 ->
+                    if (fr.size >= 3) {
+                        val keys = lookupKeys(primaryMacKey)
+                        for (key in keys) {
+                            val existing = last03[key]
+                            if (existing != null && existing.isNotEmpty() && (existing[0].toInt() and 0xFF) == 0x03) {
+                                continue
+                            }
+                            if (last03[key] != fr) {
+                                last03[key] = fr
+                                changed = true
+                            }
+                        }
+                    }
+                0x04 -> {
+                    val keys = lookupKeys(primaryMacKey)
+                    for (key in keys) {
+                        if (last04[key] != fr) {
+                            last04[key] = fr
+                            changed = true
+                        }
+                    }
+                }
+            }
+        }
+        return changed
+    }
+
+    fun buildTelemetry(
+        lookupKeys: Collection<String>,
+        last03: Map<String, ByteArray>,
+        last04: Map<String, ByteArray>,
+    ): TempivoSensorBeaconTelemetry? {
+        val keys = lookupKeys.map { it.uppercase(Locale.US) }.distinct()
+        val d03 = keys.firstNotNullOfOrNull { last03[it] }
+        val d04 = keys.firstNotNullOfOrNull { last04[it] }
+        return buildTelemetry(d03, d04)
+    }
+
+    fun buildTelemetry(adv03: ByteArray?, adv04: ByteArray?): TempivoSensorBeaconTelemetry? {
+        val summaryParts = mutableListOf<String>()
+        var firmware: String? = null
+        var batteryOk: Boolean? = null
+        var encryptionEnabled: Boolean? = null
+        var cellularStatus: String? = null
+        var measurementCounter: Long? = null
+        var readingTimestampUnix: Long? = null
+        var readingTimestampIso: String? = null
+        var periodBaseSeconds: Int? = null
+        var periodFactor: Int? = null
+        val readings = mutableListOf<TempivoSensorBeaconReading>()
+
+        if (adv03 != null && adv03.isNotEmpty()) {
+            when (adv03[0].toInt() and 0xFF) {
+                0x03 -> {
+                    val parsed = parseFw6Adv03(adv03)
+                    firmware = parsed.firmware
+                    batteryOk = parsed.batteryOk
+                    encryptionEnabled = parsed.encryptionEnabled
+                    cellularStatus = parsed.cellularStatus
+                    measurementCounter = parsed.measurementCounter
+                    readingTimestampUnix = parsed.readingTimestampUnix
+                    readingTimestampIso = parsed.readingTimestampIso
+                    periodBaseSeconds = parsed.periodBaseSeconds
+                    periodFactor = parsed.periodFactor
+                }
+                0x02 -> {
+                    val fw5 = fw5Summary(adv03)
+                    if (fw5 != null) {
+                        firmware = fw5
+                        summaryParts.add(fw5)
+                    }
+                }
+            }
+        }
+
+        if (adv04 != null && adv04.size >= 5 && (adv04[0].toInt() and 0xFF) == 0x04) {
+            var i = 1
+            while (i + 4 <= adv04.size - 2) {
+                val mtype = adv04[i].toInt() and 0xFF
+                if (mtype == 0) break
+                val raw24 =
+                    ((adv04[i + 1].toInt() and 0xFF) shl 16) or
+                        ((adv04[i + 2].toInt() and 0xFF) shl 8) or
+                        (adv04[i + 3].toInt() and 0xFF)
+                val text = decodeSlot(mtype, raw24)
+                summaryParts.add(text)
+                readings +=
+                    TempivoSensorBeaconReading(
+                        typeHex = String.format(Locale.US, "0x%02X", mtype),
+                        raw24 = raw24 and 0xFFFFFF,
+                        text = text,
+                    )
+                i += 4
+            }
+        }
+
+        val readingsCount = summaryParts.count { !it.contains("FW 5.x") }
+
+        val summary: String =
+            if (summaryParts.isEmpty()) {
+                if (adv03 != null && (adv03[0].toInt() and 0xFF) == 0x03) {
+                    readingTimestampIso?.takeIf { it.isNotEmpty() }
+                        ?: "Adv OK. Wait for scan response (measurements)."
+                } else {
+                    ""
+                }
+            } else {
+                summaryParts.take(4).joinToString(" · ")
+            }
+
+        if (summary.isEmpty() && adv03 == null && adv04 == null) return null
+
+        val sumOut =
+            summary.ifEmpty {
+                readingTimestampIso.orEmpty()
+            }
+
+        return TempivoSensorBeaconTelemetry(
+            firmware = firmware,
+            batteryOk = batteryOk,
+            encryptionEnabled = encryptionEnabled,
+            cellularStatus = cellularStatus,
+            measurementCounter = measurementCounter,
+            readingTimestampUnix = readingTimestampUnix,
+            readingTimestampIso = readingTimestampIso,
+            periodBaseSeconds = periodBaseSeconds,
+            periodFactor = periodFactor,
+            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?,
+        val encryptionEnabled: Boolean?,
+        val cellularStatus: String?,
+        val measurementCounter: Long?,
+        val readingTimestampUnix: Long?,
+        val readingTimestampIso: String?,
+        val periodBaseSeconds: Int?,
+        val periodFactor: Int?,
+    )
+
+    private fun fw5Summary(frame: ByteArray): String? {
+        if (frame.isEmpty() || (frame[0].toInt() and 0xFF) != 0x02) return null
+        val maj = frame.getOrNull(1)?.toInt()?.and(0xFF) ?: return null
+        val min = frame.getOrNull(2)?.toInt()?.and(0xFF) ?: return null
+        return "FW 5.x $maj.$min (limited broadcast decode)"
+    }
+
+    private fun splitFrames(payload: ByteArray): List<ByteArray> {
+        val out = mutableListOf<ByteArray>()
+        var i = 0
+        val n = payload.size
+        while (i < n) {
+            val b = payload[i].toInt() and 0xFF
+            if (b == 0x03 && i + ADV_FRAME_03_LEN <= n) {
+                out.add(payload.copyOfRange(i, i + ADV_FRAME_03_LEN))
+                i += ADV_FRAME_03_LEN
+            } else if (b == 0x04) {
+                var j = i + 1
+                while (j + 4 <= n) {
+                    if (j + 4 > n - 2) break
+                    val mtype = payload[j].toInt() and 0xFF
+                    if (mtype == 0 || mtype > 0x26) break
+                    j += 4
+                }
+                if (n - j >= 2) {
+                    out.add(payload.copyOfRange(i, j + 2))
+                    i = j + 2
+                } else {
+                    out.add(payload.copyOfRange(i, n))
+                    break
+                }
+            } else if (b == 0x02 && i + 3 <= n) {
+                val end = minOf(n, i + 26)
+                out.add(payload.copyOfRange(i, end))
+                i = end
+            } else {
+                i++
+            }
+        }
+        return out
+    }
+
+    private fun zigzagDecode24(raw24: Int): Int {
+        val n = raw24 and 0xFFFFFF
+        return (n shr 1) xor (-(n and 1))
+    }
+
+    private fun decodeSlot(mtype: Int, raw24: Int): String {
+        val spec = measureTypes[mtype]
+        if (spec == null) {
+            return String.format(Locale.US, "0x%02X: 0x%06X", mtype, raw24 and 0xFFFFFF)
+        }
+        if (!spec.continuous) {
+            return "(status)"
+        }
+        val z = zigzagDecode24(raw24)
+        if (spec.metaFactor == 1) {
+            val v = z * spec.resolution
+            val unit =
+                when (mtype) {
+                    0x01 -> "°C"
+                    0x02, 0x1B -> "%"
+                    0x03 -> "hPa"
+                    0x1A -> "ppm"
+                    0x21 -> "mV"
+                    0x22 -> "mA"
+                    else -> ""
+                }
+            val num =
+                if (abs(v - floor(v)) < 1e-6) {
+                    String.format(Locale.US, "%.0f", v)
+                } else {
+                    when (mtype) {
+                        0x01, 0x03, 0x0F, 0x13 -> String.format(Locale.US, "%.1f", v)
+                        0x02, 0x1B -> String.format(Locale.US, "%.0f", v)
+                        else -> String.format(Locale.US, "%g", v)
+                    }
+                }
+            return if (unit.isEmpty()) num else "$num $unit"
+        }
+        if (mtype == 0x06) {
+            val iaq = z % (1 shl 9)
+            val cal = (z shr 9) and 0x03
+            val calS = arrayOf("not_stab", "cal_req", "cal_ongoing", "cal_done")[cal.coerceAtMost(3)]
+            return "$iaq ($calS)"
+        }
+        if (mtype == 0x1A || mtype == 0x1C || mtype == 0x1D || mtype == 0x1E) {
+            val v = (z / spec.metaFactor) * spec.resolution
+            return String.format(Locale.US, "%g", v)
+        }
+        return z.toString()
+    }
+
+    private fun parseFw6Adv03(adv03: ByteArray): Adv03Parsed {
+        if (adv03.size < ADV_FRAME_03_LEN) {
+            return Adv03Parsed(null, 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
+        val minor = (fwRaw shr 5) and 0x3F
+        val lts = fwRaw and 0x1F
+        val firmware = "$major.$minor.$lts"
+
+        val st = adv03[9].toInt() and 0xFF
+        val batteryOk = (st and 1) != 0
+        val encryptionEnabled = ((st shr 3) and 1) != 0
+        val cell = (st shr 6) and 3
+        val cellLabels = arrayOf("ble_only", "cell_ok", "no_server", "net_issue")
+        val cellularStatus = cellLabels[cell]
+
+        val ts =
+            ((adv03[10].toInt() and 0xFF) shl 24) or
+                ((adv03[11].toInt() and 0xFF) shl 16) or
+                ((adv03[12].toInt() and 0xFF) shl 8) or
+                (adv03[13].toInt() and 0xFF)
+        val measurementCounter = ts.toLong() and 0xFFFFFFFFL
+        val readingTimestampUnix = ts.toLong()
+        var readingTimestampIso: String? = null
+        if (ts > 1_000_000_000L && ts < 4_000_000_000L) {
+            val fmt = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US)
+            fmt.timeZone = TimeZone.getTimeZone("UTC")
+            readingTimestampIso = fmt.format(Date(ts * 1000L))
+        }
+        val pbase = ((adv03[14].toInt() and 0xFF) shl 8) or (adv03[15].toInt() and 0xFF)
+        val pfact = ((adv03[16].toInt() and 0xFF) shl 8) or (adv03[17].toInt() and 0xFF)
+
+        return Adv03Parsed(
+            firmware = firmware,
+            batteryOk = batteryOk,
+            encryptionEnabled = encryptionEnabled,
+            cellularStatus = cellularStatus,
+            measurementCounter = measurementCounter,
+            readingTimestampUnix = readingTimestampUnix,
+            readingTimestampIso = readingTimestampIso,
+            periodBaseSeconds = pbase,
+            periodFactor = pfact,
+        )
+    }
+}

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

@@ -0,0 +1,160 @@
+package com.tempivo.sensor.beacon
+
+import android.Manifest
+import android.bluetooth.BluetoothManager
+import android.bluetooth.le.ScanCallback
+import android.bluetooth.le.ScanResult
+import android.bluetooth.le.ScanSettings
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.ContextCompat
+import java.util.Locale
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * 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).
+ */
+class TempivoSensorBeaconScanner(
+    context: Context,
+) {
+    fun interface Listener {
+        fun onDeviceFound(device: TempivoSensorBeaconDevice)
+    }
+
+    class ScanNotPermittedException(message: String) : Exception(message)
+
+    private val appContext = context.applicationContext
+    private val advLast03 = ConcurrentHashMap<String, ByteArray>()
+    private val advLast04 = ConcurrentHashMap<String, ByteArray>()
+    private var listener: Listener? = null
+    private var scanning = false
+
+    private val leScanCallback =
+        object : ScanCallback() {
+            override fun onScanResult(callbackType: Int, result: ScanResult) {
+                handleScanResult(result)
+            }
+
+            override fun onBatchScanResults(results: MutableList<ScanResult>) {
+                for (result in results) {
+                    handleScanResult(result)
+                }
+            }
+        }
+
+    /** Clears cached `0x03` / `0x04` frames. */
+    fun clearCache() {
+        advLast03.clear()
+        advLast04.clear()
+    }
+
+    fun startScan(listener: Listener) {
+        if (scanning) {
+            stopScan()
+        }
+        if (!hasBleScanPermission()) {
+            throw ScanNotPermittedException("BLE scan permission not granted")
+        }
+        val scanner = bluetoothLeScanner()
+            ?: throw IllegalStateException("Bluetooth LE scanner unavailable")
+        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
+    }
+
+    fun stopScan() {
+        if (!scanning) return
+        val scanner = bluetoothLeScanner() ?: return
+        if (!hasBleScanPermission()) {
+            scanning = false
+            listener = null
+            return
+        }
+        try {
+            scanner.stopScan(leScanCallback)
+        } catch (_: Exception) {
+        }
+        scanning = false
+        listener = null
+    }
+
+    fun isScanning(): Boolean = scanning
+
+    private fun handleScanResult(result: ScanResult) {
+        val md =
+            result.scanRecord?.getManufacturerSpecificData(TempivoSensorBeaconDecoder.MANUFACTURER_COMPANY_ID)
+                ?: return
+        val addr = result.device?.address ?: return
+        val key = TempivoSensorBeaconDecoder.macKey(addr)
+        val changed =
+            TempivoSensorBeaconDecoder.ingestManufacturerPayload(md, key, advLast03, advLast04)
+        if (!changed && !advLast03.containsKey(key) && !advLast04.containsKey(key)) {
+            return
+        }
+        val device = buildDevice(result, key) ?: return
+        listener?.onDeviceFound(device)
+    }
+
+    private fun buildDevice(result: ScanResult, key: String): TempivoSensorBeaconDevice? {
+        val addr = result.device?.address ?: return null
+        val serial = key.uppercase(Locale.US)
+        val macColons = macWithColonsFromKey(serial)
+        val telemetry =
+            TempivoSensorBeaconDecoder.buildTelemetry(
+                TempivoSensorBeaconDecoder.lookupKeys(serial),
+                advLast03,
+                advLast04,
+            )
+        val summary =
+            telemetry?.summary?.takeIf { it.isNotEmpty() }
+                ?: serial
+        val legacyHint = TempivoSensorBeaconDecoder.legacyHintFromFirmware(telemetry?.firmware)
+        return TempivoSensorBeaconDevice(
+            deviceId = addr,
+            bluetoothMacAddress = macColons,
+            serialNumber = serial,
+            rssi = result.rssi,
+            telemetry = telemetry,
+            summary = summary,
+            legacyHint = legacyHint,
+        )
+    }
+
+    private fun bluetoothLeScanner() =
+        (appContext.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
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            return ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_FINE_LOCATION) ==
+                PackageManager.PERMISSION_GRANTED
+        }
+        return true
+    }
+
+    private fun macWithColonsFromKey(key: String): String {
+        val k = key.uppercase(Locale.US)
+        if (k.length != 12) return key
+        return buildString(17) {
+            for (i in 0 until 12 step 2) {
+                if (isNotEmpty()) append(':')
+                append(k, i, i + 2)
+            }
+        }
+    }
+}

package/android/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorBeaconTypes.kt

@@ -0,0 +1,42 @@
+package com.tempivo.sensor.beacon
+
+/**
+ * One decoded measurement slot from a scan-response frame (`0x04`).
+ */
+data class TempivoSensorBeaconReading(
+    val typeHex: String,
+    val raw24: Int,
+    val text: String,
+)
+
+/**
+ * Parsed advertisement telemetry (FW6 `0x03` + optional `0x04` measurements).
+ */
+data class TempivoSensorBeaconTelemetry(
+    val firmware: String? = null,
+    val batteryOk: Boolean? = null,
+    val encryptionEnabled: Boolean? = null,
+    val cellularStatus: String? = null,
+    val measurementCounter: Long? = null,
+    val readingTimestampUnix: Long? = null,
+    val readingTimestampIso: String? = null,
+    val periodBaseSeconds: Int? = null,
+    val periodFactor: Int? = null,
+    val readings: List<TempivoSensorBeaconReading> = emptyList(),
+    val readingsCount: Int = 0,
+    val summary: String? = null,
+)
+
+/**
+ * Device reported from an active BLE scan (manufacturer `0x026C` only; no connection).
+ */
+data class TempivoSensorBeaconDevice(
+    val deviceId: String,
+    val bluetoothMacAddress: String,
+    val serialNumber: String,
+    val rssi: Int,
+    val telemetry: TempivoSensorBeaconTelemetry?,
+    val summary: String?,
+    /** `true` for older firmware families; `false` for current; `null` if unknown. */
+    val legacyHint: Boolean?,
+)

package/android/settings.gradle

@@ -0,0 +1,18 @@
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "tempivo-sensor-beacon"
+include(":library")

package/dist/decoder.js

@@ -47,29 +47,29 @@ function unitForType(mtype) {
 export function decodeMeasurementSlot(mtype, raw24) {
     const spec = MEASURE_SPECS.get(mtype);
     if (!spec) {
-        return `0x${mtype.toString(16).padStart(2, '0').toUpperCase()}: raw 0x${(raw24 & 0xffffff).toString(16).padStart(6, '0')}`;
+        return `0x${mtype.toString(16).padStart(2, '0').toUpperCase()}: 0x${(raw24 & 0xffffff).toString(16).padStart(6, '0')}`;
     }
     if (!spec.continuous) {
-        return `${spec.name}: (binary / status)`;
+        return '(status)';
     }
     const z = zigzagDecode24(raw24);
     if (spec.metaFactor === 1) {
         const v = z * spec.resolution;
         const unit = unitForType(mtype);
         const num = formatNum(v, mtype);
-        return unit ? `${spec.name} ${num} ${unit}` : `${spec.name} ${num}`;
+        return unit ? `${num} ${unit}` : num;
     }
     if (mtype === 0x06) {
         const iaq = z % (1 << 9);
         const cal = (z >> 9) & 0x03;
         const calS = ['not_stab', 'cal_req', 'cal_ongoing', 'cal_done'][Math.min(cal, 3)];
-        return `${spec.name} ${iaq} (${calS})`;
+        return `${iaq} (${calS})`;
     }
     if (mtype === 0x1a || mtype === 0x1c || mtype === 0x1d || mtype === 0x1e) {
         const v = (z / spec.metaFactor) * spec.resolution;
-        return `${spec.name} ${v}`;
+        return String(v);
     }
-    return `${spec.name} z=${z}`;
+    return String(z);
 }
 function parsedValuesFromSlot(mtype, raw24) {
     const spec = MEASURE_SPECS.get(mtype);

package/ios/Package.swift

@@ -0,0 +1,22 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "TempivoSensorBeacon",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "TempivoSensorBeacon",
+            targets: ["TempivoSensorBeacon"]
+        ),
+    ],
+    targets: [
+        .target(
+            name: "TempivoSensorBeacon",
+            path: "Sources/TempivoSensorBeacon",
+            linkerSettings: [
+                .linkedFramework("CoreBluetooth"),
+            ]
+        ),
+    ]
+)