@tempivo/sensor-beacon 0.3.2 → 0.4.3

package/README.md

@@ -82,7 +82,7 @@ stopScan();
 sub.remove();
 ```
 
-`startScan` and `connect` request Bluetooth permission. Sticker PIN is required on `connect`. Wrong PIN is `invalidPin`. `connect` stops an active scan first. HC5 (legacy GATT) and HC7 use the same call. If the first GATT path fails, the native layer retries the other. `setConfigurationJson` / `getConfiguration` use the same JSON on both. HC5 writes each rule over GATT (`setRule`). Weekly `schedule` windows apply on FW 7+ only. On HC5, rules stay on 24/7.
+`startScan` and `connect` request Bluetooth permission. Sticker PIN is required on `connect`. Wrong PIN is `invalidPin`.
 
 If a bundler misses native BLE, import `@tempivo/sensor-beacon/react-native`.
 
@@ -110,9 +110,11 @@ Same as Cellular API config profiles (`temperatureAlerts` + `schedule`). You can
 | Field | Meaning |
 |------|---------|
 | `temperatureAlerts` | Alert list. Empty array is valid. |
-| `schedule` | `{ "always": true }` is 24/7. Weekday windows apply on FW 7+. HC5 is always 24/7. |
+| `schedule` | `{ "always": true }` is 24/7. |
 
-Ignored over BLE: `slug`, `name`, `measurementIntervalMinutes`, `transmissionIntervalSeconds`. Do not pass `alarmRules`.
+Ignored over BLE: `slug`, `name`. Do not pass `alarmRules`.
+
+Optional intervals (same limits as Cellular API): `measurementIntervalMinutes` (60–600), `transmissionIntervalSeconds` (3600–604800). When both are set, uplink must be at most 60× the measurement interval. Omitted fields leave the device’s current intervals unchanged.
 
 **Each `temperatureAlerts[]` item**
 
@@ -142,20 +144,20 @@ Ignored over BLE: `slug`, `name`, `measurementIntervalMinutes`, `transmissionInt
 Sticker QR is JSON. Parse with `parseSensorQrJson`.
 
 ```json
-{ "sn": "282C024F0012", "pin": "111111", "model": "HC7" }
+{ "sn": "282C024F0012", "pin": "111111" }
 ```
 
 | Field | Type | Meaning |
 |------|------|---------|
 | `serial` | string | Device serial, 12 hex chars, no colons. From QR `sn`. |
 | `pin` | string | Sticker PIN. Required on `connect`. Also accepted as QR `resetCode`. |
-| `model` | string | Sticker model. Omitted QR `model` becomes **HC7**. `HC5` selects legacy GATT. Same `connect` call works for both. |
-| `sessionType` | `modern` \| `legacy` | GATT path. HC7 / firmware 7+ is `modern`. HC5 / firmware 6.x is `legacy`. |
+| `model` | string | Optional. Defaults to **HC7**. **HC5** is rejected. |
+| `sessionType` | `modern` | Always modern GATT (HC7 / firmware 7+). |
 | `bluetoothMac` | string | BLE MAC with colons, derived from `serial`. |
 
 ## Scan result
 
-iOS uses the same hardware scan as Tempivo. Manufacturer ads (`0x026C`) alone often miss HC7 / FW 7+. Android still filters `0x026C`.
+Filter manufacturer data on company id **0x026C**. Active scanning is on so scan-response packets arrive.
 
 | Field | Meaning |
 |------|---------|
@@ -170,10 +172,10 @@ iOS uses the same hardware scan as Tempivo. Manufacturer ads (`0x026C`) alone of
 
 | Field | Meaning |
 |------|---------|
-| `firmware` | `major.minor.patch`, e.g. `7.3.4`. |
+| `firmware` | `major.minor.patch`, e.g. `7.3.4`. Partner GATT requires firmware 7+. |
 | `batteryOk` | Battery status flag. |
 | `encryptionEnabled` | Advertisement payload encryption flag. |
-| `cellularStatus` | Advert attachment bits only: `ble_only`, `cell_ok`, `no_server`, or `net_issue`. Not ECL, SINR, or RSSI. |
+| `cellularStatus` | `ble_only`, `cell_ok`, `no_server`, or `net_issue`. |
 | `readingTimestampUnix` | Sample time as unix seconds, or null. |
 | `readingTimestampIso` | Same instant as UTC ISO-8601, or null. |
 | `measurementIntervalSeconds` | Sample interval, in seconds. |
@@ -206,7 +208,7 @@ import {
   parseSensorConfigurationJson,
 } from '@tempivo/sensor-beacon';
 
-const qr = parseSensorQrJson('{"sn":"282C024F0012","pin":"111111","model":"HC7"}');
+const qr = parseSensorQrJson('{"sn":"282C024F0012","pin":"111111"}');
 const reading = decodeSensorBeaconPayload(normalizeManufacturerBytes(advertisementBytes));
 const cfg = parseSensorConfigurationJson(/* config JSON above */);
 ```
@@ -215,7 +217,16 @@ Invalid QR or config throws `TempivoSensorError` (`invalidQr`, `invalidPin`, `in
 
 ## Android (Kotlin)
 
-AAR: `dist/tempivo-sensor-beacon.aar` after `npm run build:android`. Sources: `android-aar/library`. Request `BLUETOOTH_SCAN` and `BLUETOOTH_CONNECT` (API 31+) or location on older APIs.
+AAR after `npm run build:android` (from `packages/tempivo-sensor-beacon`):
+
+| Path | Use |
+|------|-----|
+| `android/libs/tempivo-sensor-beacon.aar` | Expo / React Native autolinking (`android/build.gradle`) |
+| `dist/tempivo-sensor-beacon.aar` | Same file; handy for plain Android `files(...)` deps |
+
+Sources: `android-aar/library`. Request `BLUETOOTH_SCAN`, `BLUETOOTH_CONNECT`, and on some OEMs **`ACCESS_FINE_LOCATION`** even on API 31+ (location on older APIs).
+
+**Scan:** temperature and other live values are in scan-response frame **`0x04`** (`telemetry.readings`). Frame **`0x03`** alone fills firmware / battery / cellular but leaves `readings` empty until an active scan delivers `0x04` (usually within a second or two). Keep scanning; do not stop on the first event.
 
 ```kotlin
 val qr = TempivoSensorQrParser.parse(stickerQrText)

package/android/build.gradle

@@ -4,14 +4,14 @@ plugins {
 }
 
 group = 'com.tempivo.sensor.beacon'
-version = '0.3.1'
+version = '0.4.3'
 
 android {
   namespace "expo.modules.tempivosensorbeacon"
   defaultConfig {
     minSdk 26
     versionCode 1
-    versionName "0.3.1"
+    versionName "0.4.3"
   }
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_17
@@ -24,9 +24,17 @@ android {
   }
 }
 
-def aarFile = file("libs/tempivo-sensor-beacon.aar")
-if (!aarFile.exists()) {
-  throw new GradleException("Missing android/libs/tempivo-sensor-beacon.aar. From the package root run: npm run build:android")
+// Prefer android/libs (what Expo autolinking uses). Fall back to dist/ from `npm run build:android`.
+def aarCandidates = [
+  file("${projectDir}/libs/tempivo-sensor-beacon.aar"),
+  file("${projectDir}/../dist/tempivo-sensor-beacon.aar"),
+]
+def aarFile = aarCandidates.find { it.exists() }
+if (aarFile == null) {
+  throw new GradleException(
+    "Missing tempivo-sensor-beacon.aar (looked in android/libs/ and dist/). " +
+      "From packages/tempivo-sensor-beacon run: npm run build:android"
+  )
 }
 
 dependencies {

package/android/src/main/AndroidManifest.xml

@@ -5,6 +5,7 @@
     android:name="android.permission.BLUETOOTH_SCAN"
     android:usesPermissionFlags="neverForLocation" />
   <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
-  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="30" />
+  <!-- Some OEMs (e.g. Samsung) still filter BLE scan results without location on API 31+. -->
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
   <uses-feature android:name="android.hardware.bluetooth_le" android:required="false" />
 </manifest>

package/android/src/main/java/expo/modules/tempivosensorbeacon/SensorBeaconNative.java

@@ -54,15 +54,8 @@ final class SensorBeaconNative {
 
   Map<String, Object> connect(Context context, String qrJson) {
     try {
-      stopScan();
-      try {
-        Thread.sleep(200);
-      } catch (InterruptedException ignored) {
-        Thread.currentThread().interrupt();
-      }
       TempivoSensorQr qr = TempivoSensorQrParser.INSTANCE.parse(qrJson);
-      TempivoSensorBeaconScanner.SeenDevice seen = scanner != null ? scanner.lookup(qr.getSerial()) : null;
-      requireSession(context).connectBlocking(qr, seen);
+      requireSession(context).connectBlocking(qr);
       return qrMap(qr);
     } catch (Throwable error) {
       throw wrap(error);
@@ -142,14 +135,13 @@ final class SensorBeaconNative {
     }
     TempivoSensorException sensor = findSensor(error);
     if (sensor != null) {
-      return new NativeError(toJs(sensor.getCode()), TempivoSensorException.sanitizeClientMessage(sensor.getMessage()), null);
+      return new NativeError(toJs(sensor.getCode()), sensor.getMessage(), error);
     }
     if (error instanceof TempivoSensorBeaconScanner.ScanNotPermittedException) {
-      String permitted = TempivoSensorException.sanitizeClientMessage(error.getMessage());
-      return new NativeError("runtimeUnavailable", permitted.isEmpty() ? "Bluetooth permission is required." : permitted, null);
+      return new NativeError("runtimeUnavailable", error.getMessage(), error);
     }
-    String message = TempivoSensorException.sanitizeClientMessage(error.getMessage());
-    return new NativeError("unknown", message.isEmpty() ? "Sensor request failed." : message, null);
+    String message = error.getMessage();
+    return new NativeError("unknown", message != null ? message : "Sensor request failed.", error);
   }
 
   private static TempivoSensorException findSensor(Throwable error) {
@@ -189,9 +181,7 @@ final class SensorBeaconNative {
     payload.put("serial", qr.getSerial());
     payload.put("pin", qr.getPin());
     payload.put("model", qr.getModel());
-    payload.put(
-        "sessionType",
-        qr.getSessionType() == TempivoSensorSession.SessionType.LEGACY ? "legacy" : "modern");
+    payload.put("sessionType", "modern");
     payload.put("bluetoothMac", qr.getBluetoothMac());
     return payload;
   }

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

@@ -8,7 +8,7 @@ import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-import com.tempivo.sensor.beacon.TempivoSensorException
+import kotlinx.coroutines.launch
 
 class TempivoSensorBeaconModule : Module() {
   private val native = SensorBeaconNative()
@@ -25,8 +25,11 @@ class TempivoSensorBeaconModule : Module() {
 
     AsyncFunction("startScan") {
       try {
+        val ctx = appContext
         native.startScan(requireContext()) { payload ->
-          sendEvent("onDeviceFound", payload)
+          ctx.mainQueue.launch {
+            sendEvent("onDeviceFound", payload)
+          }
         }
       } catch (error: Throwable) {
         throw error.toSensorException()
@@ -102,7 +105,12 @@ class TempivoSensorBeaconModule : Module() {
 
   private fun blePermissions(): Array<String> {
     return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      arrayOf(Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT)
+      arrayOf(
+        Manifest.permission.BLUETOOTH_SCAN,
+        Manifest.permission.BLUETOOTH_CONNECT,
+        // Some Samsung/OEM builds still filter scan results without location granted.
+        Manifest.permission.ACCESS_FINE_LOCATION,
+      )
     } else {
       arrayOf(
         Manifest.permission.ACCESS_FINE_LOCATION,
@@ -117,8 +125,7 @@ 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, null)
+    return CodedException(native.code, native.message, this)
   }
-  val clean = TempivoSensorException.sanitizeClientMessage(message)
-  return CodedException("unknown", clean.ifEmpty { "Sensor request failed." }, null)
+  return CodedException("unknown", message ?: "Sensor request failed.", this)
 }

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

@@ -1,5 +1,6 @@
 package com.tempivo.sensor.beacon
 
+import pl.efento.mobile.bluetooth.model.MeasurementPeriod
 import pl.efento.mobile.bluetooth.model.sensor.Action
 import pl.efento.mobile.bluetooth.model.sensor.DisabledCondition
 import pl.efento.mobile.bluetooth.model.sensor.HighThresholdCondition
@@ -93,12 +94,9 @@ internal object PartnerBleRules {
         return rules to calendars
     }
 
-    fun decompile(cfg: SensorConfiguration): TempivoSensorConfiguration =
-        decompile(cfg.rules.orEmpty(), cfg.ruleCalendars)
-
-    fun decompile(rules: List<Rule>, calendars: List<RuleCalendar>? = null): TempivoSensorConfiguration {
+    fun decompile(cfg: SensorConfiguration): TempivoSensorConfiguration {
         val padded = MutableList(12) { i ->
-            rules.getOrNull(i)
+            cfg.rules.orEmpty().getOrNull(i)
                 ?: Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION)
         }
         val orRefs = orSelectedPairs(padded)
@@ -167,7 +165,20 @@ internal object PartnerBleRules {
             }
         }
 
-        return TempivoSensorConfiguration(alerts, decompileSchedule(calendars))
+        return TempivoSensorConfiguration(
+            alerts,
+            decompileSchedule(cfg.ruleCalendars),
+            measurementIntervalMinutes = decompileMeasurementMinutes(cfg.measurementPeriod),
+            transmissionIntervalSeconds = cfg.transmissionInterval?.value?.takeIf { it > 0 },
+        )
+    }
+
+    private fun decompileMeasurementMinutes(period: MeasurementPeriod?): Double? {
+        if (period == null) return null
+        val factor = if (period.factor == 0) 1 else period.factor
+        val sec = period.base * factor
+        if (sec <= 0) return null
+        return sec / 60.0
     }
 
     private fun orSelectedPairs(rules: List<Rule>): List<Pair<Int, Int>> {

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

@@ -2,17 +2,16 @@ package com.tempivo.sensor.beacon
 
 import android.app.Application
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.withTimeout
 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.DisabledCondition
+import pl.efento.mobile.bluetooth.model.MeasurementPeriod
 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.cellular.TransmissionInterval
 
 /**
  * Internal adapter to the sensor BLE runtime. Keep vendor types inside this file.
@@ -33,26 +32,15 @@ internal object SensorBleRuntime {
     fun mapError(e: Throwable): TempivoSensorException {
         if (e is TempivoSensorException) return e
         val className = e.javaClass.name
-        val detail = clientSafeDetail(e.message)
         return when {
             e is InvalidResetCodeException || className.contains("InvalidResetCode") ->
-                TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "Invalid PIN.")
+                TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "Invalid PIN.", e)
             e is UnsupportedCommandException || className.contains("UnsupportedCommand") ->
-                TempivoSensorException(TempivoSensorException.Code.UNSUPPORTED_COMMAND, "Unsupported command.")
+                TempivoSensorException(TempivoSensorException.Code.UNSUPPORTED_COMMAND, "Unsupported command.", e)
             className.contains("NotConnected") ->
-                TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.")
-            className.contains("Connect", ignoreCase = true) ||
-                detail.contains("connect", ignoreCase = true) ||
-                detail.contains("timeout", ignoreCase = true) ->
-                TempivoSensorException(
-                    TempivoSensorException.Code.CONNECT_FAILED,
-                    if (detail.isNotEmpty()) "Could not connect. $detail" else "Could not connect.",
-                )
+                TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.", e)
             else ->
-                TempivoSensorException(
-                    TempivoSensorException.Code.UNKNOWN,
-                    if (detail.isNotEmpty()) "Sensor request failed. $detail" else "Sensor request failed.",
-                )
+                TempivoSensorException(TempivoSensorException.Code.UNKNOWN, "Sensor request failed.", e)
         }
     }
 
@@ -61,125 +49,50 @@ internal object SensorBleRuntime {
         serial: String,
         bluetoothMac: String,
         pin: Int,
-        legacy: Boolean,
-        deviceId: String = serial,
-        encryptionKey: String = "",
     ): Session {
         initialize(application)
         val mac = BluetoothMacAddress(bluetoothMac)
-        val id = deviceId.ifBlank { serial }
-        suspend fun open(useLegacy: Boolean): Session {
-            return if (useLegacy) {
-                val c =
-                    EfentoBluetooth.sensorLegacyConnection(
-                        deviceID = id,
-                        bluetoothMacAddress = mac,
-                        resetCode = pin,
-                        encryptionKey = encryptionKey,
-                    )
-                c.connect()
-                if (pin >= 0) c.resetCode = pin
-                if (encryptionKey.isNotEmpty()) c.encryptionKey = encryptionKey
-                Session.Legacy(c)
-            } else {
-                val c =
-                    EfentoBluetooth.sensorConnection(
-                        deviceID = id,
-                        bluetoothMacAddress = mac,
-                        resetCode = pin,
-                        encryptionKey = encryptionKey,
-                    )
-                c.connect()
-                if (pin >= 0) c.resetCode = pin
-                if (encryptionKey.isNotEmpty()) c.encryptionKey = encryptionKey
-                Session.Modern(c)
-            }
-        }
-        return try {
-            open(legacy)
-        } catch (first: Throwable) {
-            val mapped = mapError(first)
-            if (mapped.code == TempivoSensorException.Code.INVALID_PIN) throw mapped
-            try {
-                open(!legacy)
-            } catch (second: Throwable) {
-                val mappedSecond = mapError(second)
-                if (mappedSecond.code == TempivoSensorException.Code.UNKNOWN) {
-                    throw TempivoSensorException(
-                        TempivoSensorException.Code.CONNECT_FAILED,
-                        mapped.message + " Then " + mappedSecond.message,
-                        second,
-                    )
-                }
-                throw mappedSecond
-            }
-        }
+        val c =
+            EfentoBluetooth.sensorConnection(
+                deviceID = serial,
+                bluetoothMacAddress = mac,
+                resetCode = pin,
+                encryptionKey = "",
+            )
+        c.connect()
+        if (pin >= 0) c.resetCode = pin
+        return Session(c)
     }
 
     suspend fun disconnect(session: Session?) {
-        when (session) {
-            is Session.Modern -> runCatching { session.connection.disconnect() }
-            is Session.Legacy -> runCatching { session.connection.disconnect() }
-            null -> Unit
-        }
+        session?.let { runCatching { it.connection.disconnect() } }
     }
 
-    suspend fun readPartnerConfiguration(session: Session): TempivoSensorConfiguration {
-        return when (session) {
-            is Session.Modern -> PartnerBleRules.decompile(modernGetConfiguration(session.connection))
-            is Session.Legacy ->
-                PartnerBleRules.decompile(session.connection.commands.getRules { }, emptyList())
-        }
-    }
+    suspend fun readConfiguration(session: Session): SensorConfiguration =
+        modernGetConfiguration(session.connection)
 
-    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 -> writeLegacyRules(session.connection, rules)
+    suspend fun writeConfiguration(session: Session, cfg: TempivoSensorConfiguration) {
+        val (rules, calendars) = compileRules(cfg)
+        val base = modernGetConfiguration(session.connection)
+        var next = base.copy(rules = rules.take(12), ruleCalendars = calendars.take(6))
+        cfg.measurementIntervalMinutes?.let { minutes ->
+            val baseSec = (minutes * 60.0).toInt().coerceAtLeast(1)
+            next = next.copy(measurementPeriod = MeasurementPeriod(baseSec, 1))
         }
-    }
-
-    private suspend fun writeLegacyRules(legacy: SensorLegacyConnection, rules: List<Rule>) {
-        val cmd = legacy.commands
-        val current = runCatching { cmd.getRules { } }.getOrNull().orEmpty()
-        val currentActive =
-            current.filter { it.condition !is DisabledCondition }.map { it.id }.toSet()
-        for (rule in rules.take(12)) {
-            val disabled = rule.condition is DisabledCondition
-            if (disabled && rule.id !in currentActive) continue
-            withTimeout(20_000) { cmd.setRule(rule) { } }
+        cfg.transmissionIntervalSeconds?.let { sec ->
+            next = next.copy(transmissionInterval = TransmissionInterval(sec))
         }
+        session.connection.commands.setConfiguration(next) { }
     }
 
     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)
-                }
-            }
-        }
+        session.connection.commands.triggerCommunicationWithServer { }
+        return TempivoSensorSession.TriggerResult(ok = true, supported = true)
     }
 
     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)
-        }
+        val ext = session.connection.commands.getExtendedConfiguration { }
+        return TempivoSensorCalibrationDecoder.decode(ext.laboratoryCalibrationTimestamp)
     }
 
     fun compileRules(cfg: TempivoSensorConfiguration): Pair<List<Rule>, List<RuleCalendar>> =
@@ -204,8 +117,5 @@ internal object SensorBleRuntime {
         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()
-    }
+    class Session(val connection: SensorConnection)
 }

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

@@ -0,0 +1,138 @@
+package com.tempivo.sensor.beacon
+
+import pl.efento.mobile.bluetooth.measurement.Measurement
+import pl.efento.mobile.bluetooth.model.Sensor
+import kotlin.math.abs
+import kotlin.math.floor
+
+/** Advertisement telemetry from Efento SDK [Sensor] (same path as Tempivo Capacitor app). */
+internal object SensorSdkScanTelemetry {
+    fun fromSensor(sensor: Sensor): TempivoSensorBeaconTelemetry {
+        val readings = buildReadings(sensor)
+        val summary = sensorAdvertisementSummary(sensor, readings.size)
+        val fw = sensor.softwareVersion
+        val lts = fw.lts ?: 0
+        val periodBase = sensor.measurementPeriod.base
+        val periodFactor = sensor.measurementPeriod.factor
+        val intervalSec =
+            if (periodBase > 0) {
+                periodBase * (if (periodFactor == 0) 1 else periodFactor)
+            } else {
+                null
+            }
+        val ts = sensor.measurementsTimestamp
+        return TempivoSensorBeaconTelemetry(
+            firmware = "${fw.major}.${fw.minor}.$lts",
+            batteryOk = sensor.batteryStatus.name.contains("OK", ignoreCase = true),
+            encryptionEnabled = sensor.encryptionStatus.name.contains("ENABLED", ignoreCase = true),
+            cellularStatus = resolveCellularStatus(sensor),
+            measurementCounter = sensor.counter.takeIf { it > 0 }?.toLong(),
+            readingTimestampUnix = ts.takeIf { it > 0 },
+            measurementIntervalSeconds = intervalSec,
+            readings = readings,
+            readingsCount = readings.size,
+            summary = summary,
+        )
+    }
+
+    fun deviceFromSensor(sensor: Sensor): TempivoSensorBeaconDevice {
+        val mac = sensor.bluetoothMacAddress.withColons
+        val serial = TempivoSensorBeaconDecoder.macKey(mac)
+        val telemetry = fromSensor(sensor)
+        return TempivoSensorBeaconDevice(
+            deviceId = sensor.id,
+            bluetoothMacAddress = mac,
+            serialNumber = serial,
+            rssi = sensor.rssi,
+            telemetry = telemetry,
+            summary = telemetry.summary ?: serial,
+        )
+    }
+
+    private fun sensorAdvertisementSummary(
+        sensor: Sensor,
+        readingsCount: Int,
+    ): String {
+        val parts = measurementSummaryParts(sensor)
+        if (parts.isNotEmpty()) return parts.take(4).joinToString(" · ")
+        val fw = sensor.softwareVersion
+        val lts = fw.lts ?: 0
+        return if (readingsCount == 0) {
+            "${fw.major}.${fw.minor}.$lts"
+        } else {
+            "${fw.major}.${fw.minor}.$lts"
+        }
+    }
+
+    private fun buildReadings(sensor: Sensor): List<TempivoSensorBeaconReading> {
+        val out = mutableListOf<TempivoSensorBeaconReading>()
+        for ((_, measurement) in sensor.measurements) {
+            if (!measurement.isValid) continue
+            out +=
+                TempivoSensorBeaconReading(
+                    typeHex = measurementTypeHex(measurement),
+                    raw24 = 0,
+                    text = formatMeasurementText(measurement),
+                )
+        }
+        return out
+    }
+
+    private fun measurementTypeHex(m: Measurement<*>): String {
+        val typeName = m.type.toString()
+        return Regex("0x[0-9A-Fa-f]+").find(typeName)?.value ?: typeName
+    }
+
+    private fun formatMeasurementText(m: Measurement<*>): String {
+        val type = m.type.toString().substringAfterLast('.').replace('_', ' ')
+        val v = m.value
+        return when (v) {
+            is Double -> "$type ${formatNum(v)}"
+            is Float -> "$type ${formatNum(v.toDouble())}"
+            is Int -> "$type $v"
+            is Long -> "$type $v"
+            else -> "$type $v"
+        }
+    }
+
+    private fun formatNum(v: Double): String =
+        if (abs(v - floor(v)) < 0.0001) {
+            v.toInt().toString()
+        } else {
+            v.toString()
+        }
+
+    private fun measurementSummaryParts(sensor: Sensor): List<String> {
+        val out = mutableListOf<String>()
+        for ((_, measurement) in sensor.measurements) {
+            if (!measurement.isValid) continue
+            out.add(formatMeasurementText(measurement))
+        }
+        return out
+    }
+
+    private fun resolveCellularStatus(sensor: Sensor): String? {
+        sensor.cellularStatus?.let { return mapCellularStatus(it) }
+        return mapConnectivityToCellular(sensor.connectivityStatus)
+    }
+
+    private fun mapCellularStatus(status: Sensor.CellularStatus): String =
+        when (status) {
+            Sensor.CellularStatus.COMMUNICATION_WITH_SERVER_DISABLED -> "ble_only"
+            Sensor.CellularStatus.OPERATING_CORRECTLY -> "cell_ok"
+            Sensor.CellularStatus.CLOUD_PROBLEM -> "no_server"
+            Sensor.CellularStatus.NETWORK_PROBLEM -> "net_issue"
+        }
+
+    private fun mapConnectivityToCellular(status: Sensor.ConnectivityStatus): String? {
+        val n = status.name.uppercase()
+        return when {
+            n.contains("BLE_ONLY") || n.contains("BLUETOOTH_ONLY") -> "ble_only"
+            n.contains("SERVER") || n.contains("CLOUD") -> "no_server"
+            n.contains("NETWORK") || n.contains("NET") -> "net_issue"
+            n.contains("CELLULAR") && n.contains("OK") -> "cell_ok"
+            n.contains("WORKING") && n.contains("CORRECT") -> "cell_ok"
+            else -> null
+        }
+    }
+}