@tempivo/sensor-beacon 0.3.3 → 0.4.7

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

@@ -1,6 +1,7 @@
 package com.tempivo.sensor.beacon
 
 import android.Manifest
+import android.app.Application
 import android.bluetooth.BluetoothManager
 import android.bluetooth.le.ScanCallback
 import android.bluetooth.le.ScanResult
@@ -11,12 +12,21 @@ import android.os.Build
 import androidx.core.content.ContextCompat
 import java.util.Locale
 import java.util.concurrent.ConcurrentHashMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import pl.efento.mobile.bluetooth.model.Device as BleScanDevice
+import pl.efento.mobile.bluetooth.model.Sensor
 
 /**
- * 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).
+ * Tempivo sensor discovery: alternate runtime `deviceFlow()` with manufacturer `0x026C` adv-only windows.
  */
 class TempivoSensorBeaconScanner(
     context: Context,
@@ -35,31 +45,40 @@ class TempivoSensorBeaconScanner(
         val encryptionEnabled: Boolean?,
     )
 
-    private val appContext = context.applicationContext
+    companion object {
+        private const val SDK_SCAN_WINDOW_MS = 12_000L
+        private const val ADV_SCAN_WINDOW_MS = 5_000L
+    }
+
+    private val application = context.applicationContext as Application
     private val advLast03 = ConcurrentHashMap<String, ByteArray>()
     private val advLast04 = ConcurrentHashMap<String, ByteArray>()
     private val lastSeen = ConcurrentHashMap<String, SeenDevice>()
+    private val lastSensorBySerial = ConcurrentHashMap<String, Sensor>()
     private var listener: Listener? = null
     private var scanning = false
+    private var advOnlyWindowActive = false
+    private val scanScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    private var scanJob: Job? = null
 
     private val leScanCallback =
         object : ScanCallback() {
             override fun onScanResult(callbackType: Int, result: ScanResult) {
-                handleScanResult(result)
+                handleAdvScanResult(result)
             }
 
             override fun onBatchScanResults(results: MutableList<ScanResult>) {
                 for (result in results) {
-                    handleScanResult(result)
+                    handleAdvScanResult(result)
                 }
             }
         }
 
-    /** Clears cached `0x03` / `0x04` frames. */
     fun clearCache() {
         advLast03.clear()
         advLast04.clear()
         lastSeen.clear()
+        lastSensorBySerial.clear()
     }
 
     fun lookup(serial: String): SeenDevice? {
@@ -68,75 +87,114 @@ class TempivoSensorBeaconScanner(
     }
 
     fun startScan(listener: Listener) {
-        if (scanning) {
-            stopScan()
-        }
+        if (scanning) stopScan()
         if (!hasBleScanPermission()) {
             throw ScanNotPermittedException("BLE scan permission not granted")
         }
-        val scanner = bluetoothLeScanner()
-            ?: throw IllegalStateException("Bluetooth LE scanner unavailable")
+        SensorBleRuntime.initialize(application)
         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
+        advOnlyWindowActive = false
+        clearCache()
+        stopParallelAdvScan()
+        scanJob =
+            scanScope.launch {
+                val sdkScanner = SensorBleVendor.scanner()
+                while (isActive && scanning) {
+                    advOnlyWindowActive = false
+                    val sdkCollect =
+                        launch {
+                            sdkScanner
+                                .deviceFlow()
+                                .catch { /* keep alternating windows alive */ }
+                                .collect { device ->
+                                    emitSdkDevice(device)
+                                }
+                        }
+                    delay(SDK_SCAN_WINDOW_MS)
+                    sdkCollect.cancel()
+                    sdkCollect.join()
+                    if (!isActive || !scanning) break
+
+                    advOnlyWindowActive = true
+                    withContext(Dispatchers.Main) { startParallelAdvScan() }
+                    delay(ADV_SCAN_WINDOW_MS)
+                    advOnlyWindowActive = false
+                    withContext(Dispatchers.Main) { stopParallelAdvScan() }
+                }
+            }
     }
 
     fun stopScan() {
-        if (!scanning) return
-        val scanner = bluetoothLeScanner() ?: return
-        if (!hasBleScanPermission()) {
-            scanning = false
-            listener = null
-            return
-        }
-        try {
-            scanner.stopScan(leScanCallback)
-        } catch (_: Exception) {
-        }
         scanning = false
+        advOnlyWindowActive = false
+        scanJob?.cancel()
+        scanJob = null
+        stopParallelAdvScan()
         listener = null
     }
 
     fun isScanning(): Boolean = scanning
 
-    private fun handleScanResult(result: ScanResult) {
+    private fun emitSdkDevice(device: BleScanDevice) {
+        if (device !is Sensor) return
+        val mapped = SensorSdkScanTelemetry.deviceFromSensor(device)
+        val serial = mapped.serialNumber.uppercase(Locale.US)
+        lastSensorBySerial[serial] = device
+        rememberSeen(mapped)
+        listener?.onDeviceFound(mapped)
+    }
+
+    private fun handleAdvScanResult(result: ScanResult) {
+        if (!advOnlyWindowActive) return
         val record = result.scanRecord ?: return
         val addr = result.device?.address ?: return
         val key = TempivoSensorBeaconDecoder.macKey(addr)
-        // Raw AD parse keeps both 0x03 and 0x04 when they share company id 0x026C.
-        // getManufacturerSpecificData(0x026C) can retain only one of the two.
-        val payloads =
-            TempivoSensorBeaconDecoder.manufacturerPayloadsFromScanRecordBytes(record.bytes)
-                .ifEmpty {
-                    val single =
-                        record.getManufacturerSpecificData(TempivoSensorBeaconDecoder.MANUFACTURER_COMPANY_ID)
-                    if (single != null) listOf(single) else emptyList()
-                }
+        val payloads = TempivoSensorBeaconDecoder.manufacturerPayloadsFromScanRecord(record)
         if (payloads.isEmpty()) return
 
-        var changed = false
         for (md in payloads) {
-            if (TempivoSensorBeaconDecoder.ingestManufacturerPayload(md, key, advLast03, advLast04)) {
-                changed = true
-            }
+            TempivoSensorBeaconDecoder.ingestManufacturerPayload(md, key, advLast03, advLast04)
         }
-        if (!changed && !advLast03.containsKey(key) && !advLast04.containsKey(key)) {
+        val serialHint =
+            payloads.asSequence()
+                .mapNotNull { TempivoSensorBeaconDecoder.serialKeyFromAdv03(it) }
+                .firstOrNull()
+        val lookupKeys = TempivoSensorBeaconDecoder.lookupKeys(key, serialHint)
+        if (lookupKeys.none { advLast03.containsKey(it) || advLast04.containsKey(it) }) {
             return
         }
-        val device = buildDevice(result, key) ?: return
+
+        val advSerial =
+            lookupKeys.asSequence()
+                .mapNotNull { advLast03[it] }
+                .mapNotNull { TempivoSensorBeaconDecoder.serialKeyFromAdv03(it) }
+                .firstOrNull()
+        val serial = (advSerial ?: key).uppercase(Locale.US)
+
+        lastSensorBySerial[serial]?.let { sensor ->
+            val refreshed = SensorSdkScanTelemetry.deviceFromSensor(sensor)
+            rememberSeen(refreshed)
+            listener?.onDeviceFound(refreshed)
+            return
+        }
+
+        val device = buildAdvDevice(result, key, lookupKeys) ?: return
+        rememberSeen(device)
         listener?.onDeviceFound(device)
     }
 
-    private fun buildDevice(result: ScanResult, key: String): TempivoSensorBeaconDevice? {
+    private fun buildAdvDevice(
+        result: ScanResult,
+        key: String,
+        lookupKeys: List<String>,
+    ): TempivoSensorBeaconDevice? {
         val addr = result.device?.address ?: return null
-        val frame = advLast03[key]
-        val advSerial = frame?.let { TempivoSensorBeaconDecoder.serialKeyFromAdv03(it) }
+        val advSerial =
+            lookupKeys.asSequence()
+                .mapNotNull { advLast03[it] }
+                .mapNotNull { TempivoSensorBeaconDecoder.serialKeyFromAdv03(it) }
+                .firstOrNull()
         val serial = (advSerial ?: key).uppercase(Locale.US)
         val macColons = macWithColonsFromKey(if (key.length == 12) key else serial)
         val telemetry =
@@ -145,43 +203,71 @@ class TempivoSensorBeaconScanner(
                 advLast03,
                 advLast04,
             )
-        val summary =
-            telemetry?.summary?.takeIf { it.isNotEmpty() }
-                ?: serial
-        val device =
-            TempivoSensorBeaconDevice(
-                deviceId = addr,
-                bluetoothMacAddress = macColons,
-                serialNumber = serial,
-                rssi = result.rssi,
-                telemetry = telemetry,
-                summary = summary,
-            )
+        val summary = telemetry?.summary?.takeIf { it.isNotEmpty() } ?: serial
+        return TempivoSensorBeaconDevice(
+            deviceId = addr,
+            bluetoothMacAddress = macColons,
+            serialNumber = serial,
+            rssi = result.rssi,
+            model = SensorModelHint.fromFirmware(telemetry?.firmware),
+            telemetry = telemetry,
+            summary = summary,
+        )
+    }
+
+    private fun rememberSeen(device: TempivoSensorBeaconDevice) {
         val seen =
             SeenDevice(
-                deviceId = addr,
-                bluetoothMac = macColons,
-                serial = serial,
-                firmware = telemetry?.firmware,
-                encryptionEnabled = telemetry?.encryptionEnabled,
+                deviceId = device.deviceId,
+                bluetoothMac = device.bluetoothMacAddress,
+                serial = device.serialNumber,
+                firmware = device.telemetry?.firmware,
+                encryptionEnabled = device.telemetry?.encryptionEnabled,
             )
-        lastSeen[serial] = seen
-        lastSeen[key.uppercase(Locale.US)] = seen
-        return device
+        lastSeen[device.serialNumber.uppercase(Locale.US)] = seen
+        lastSeen[TempivoSensorBeaconDecoder.macKey(device.serialNumber)] = seen
+    }
+
+    private fun startParallelAdvScan() {
+        if (!hasBleScanPermission()) return
+        val scanner = bluetoothLeScanner() ?: return
+        val settings =
+            ScanSettings.Builder()
+                .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
+                .setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES)
+                .build()
+        try {
+            scanner.startScan(null, settings, leScanCallback)
+        } catch (_: Exception) {
+        }
+    }
+
+    private fun stopParallelAdvScan() {
+        if (!hasBleScanPermission()) return
+        val scanner = bluetoothLeScanner() ?: return
+        try {
+            scanner.stopScan(leScanCallback)
+        } catch (_: Exception) {
+        }
     }
 
     private fun bluetoothLeScanner() =
-        (appContext.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager)
+        (application.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
+            val scanGranted =
+                ContextCompat.checkSelfPermission(application, Manifest.permission.BLUETOOTH_SCAN) ==
+                    PackageManager.PERMISSION_GRANTED
+            val locationGranted =
+                ContextCompat.checkSelfPermission(application, Manifest.permission.ACCESS_FINE_LOCATION) ==
+                    PackageManager.PERMISSION_GRANTED
+            return scanGranted && locationGranted
         }
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            return ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_FINE_LOCATION) ==
+            return ContextCompat.checkSelfPermission(application, Manifest.permission.ACCESS_FINE_LOCATION) ==
                 PackageManager.PERMISSION_GRANTED
         }
         return true

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

@@ -35,6 +35,8 @@ data class TempivoSensorBeaconDevice(
     val bluetoothMacAddress: String,
     val serialNumber: String,
     val rssi: Int,
+    /** HC7 when advertisement firmware is missing; else inferred from FW major. */
+    val model: String = SensorModelHint.DEFAULT_MODEL,
     val telemetry: TempivoSensorBeaconTelemetry?,
     val summary: String?,
 )

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

@@ -7,8 +7,9 @@ data class TempivoSensorQr(
     val serial: String,
     val pin: String,
     val model: String?,
-    val sessionType: TempivoSensorSession.SessionType,
     val bluetoothMac: String,
+    /** SDK `device.id` from scan when it differs from sticker serial. */
+    val deviceId: String? = null,
 )
 
 object TempivoSensorQrParser {
@@ -30,13 +31,22 @@ object TempivoSensorQrParser {
         }
     }
 
-    fun sessionTypeFromModel(model: String?): TempivoSensorSession.SessionType {
-        if (model.isNullOrBlank()) return TempivoSensorSession.SessionType.MODERN
+    fun normalizeMac(value: String): String {
+        val trimmed = value.trim()
+        if (trimmed.contains(':')) {
+            val key = normalizeSerial(trimmed.replace(":", ""))
+            return bluetoothMacFromSerial(key)
+        }
+        return bluetoothMacFromSerial(trimmed)
+    }
+
+    fun assertSupportedModel(model: String) {
         val m = model.trim().uppercase(Locale.US).replace("-", "")
-        return if (m == "HC5" || m.startsWith("6")) {
-            TempivoSensorSession.SessionType.LEGACY
-        } else {
-            TempivoSensorSession.SessionType.MODERN
+        if (m == "HC5") {
+            throw TempivoSensorException(
+                TempivoSensorException.Code.INVALID_QR,
+                "HC5 is not supported by the partner SDK. Use HC7 sensors.",
+            )
         }
     }
 
@@ -61,13 +71,21 @@ object TempivoSensorQrParser {
             throw TempivoSensorException(TempivoSensorException.Code.INVALID_QR, "QR is missing PIN.")
         }
         val model = rec.optString("model").trim().ifEmpty { DEFAULT_MODEL }
+        assertSupportedModel(model)
         val hex = if (serial.length == 12) serial else serial.takeLast(12)
+        val macOverride =
+            sequenceOf("bluetoothMac", "bluetoothMacAddress", "mac")
+                .mapNotNull { key ->
+                    rec.optString(key).trim().takeIf { it.isNotEmpty() }
+                }
+                .firstOrNull()
+        val deviceId = rec.optString("deviceId").trim().ifEmpty { null }
         return TempivoSensorQr(
             serial = serial,
             pin = pin,
             model = model,
-            sessionType = sessionTypeFromModel(model),
-            bluetoothMac = bluetoothMacFromSerial(hex),
+            bluetoothMac = macOverride?.let { normalizeMac(it) } ?: bluetoothMacFromSerial(hex),
+            deviceId = deviceId,
         )
     }
 

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

@@ -1,6 +1,5 @@
 package com.tempivo.sensor.beacon
 
-import android.app.Application
 import android.content.Context
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
@@ -14,17 +13,11 @@ import kotlinx.coroutines.withContext
 class TempivoSensorSession(
     context: Context,
 ) {
-    enum class SessionType {
-        MODERN,
-        LEGACY,
-    }
-
     data class TriggerResult(
         val ok: Boolean,
-        val supported: Boolean,
     )
 
-    private val application = context.applicationContext as Application
+    private val application = context.applicationContext as android.app.Application
     private val mutex = Mutex()
     private var session: SensorBleRuntime.Session? = null
 
@@ -32,11 +25,16 @@ class TempivoSensorSession(
         serial: String,
         bluetoothMac: String,
         pin: String,
-        sessionType: SessionType = SessionType.MODERN,
+        deviceId: String? = null,
     ) {
-        val pinInt =
-            pin.trim().toIntOrNull()
-                ?: throw TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "PIN must be numeric.")
+        val trimmedPin = pin.trim()
+        if (trimmedPin.isEmpty()) {
+            throw TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "PIN must be numeric.")
+        }
+        if (!trimmedPin.matches(Regex("^\\d+$"))) {
+            throw TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "PIN must be numeric.")
+        }
+        val resolvedDeviceId = deviceId?.trim()?.takeIf { it.isNotEmpty() } ?: serial
         try {
             mutex.withLock {
                 SensorBleRuntime.disconnect(session)
@@ -45,10 +43,9 @@ class TempivoSensorSession(
                     withContext(Dispatchers.Main) {
                         SensorBleRuntime.connect(
                             application = application,
-                            serial = TempivoSensorQrParser.normalizeSerial(serial),
+                            deviceId = resolvedDeviceId,
                             bluetoothMac = bluetoothMac,
-                            pin = pinInt,
-                            legacy = sessionType == SessionType.LEGACY,
+                            pin = trimmedPin,
                         )
                     }
             }
@@ -63,8 +60,12 @@ class TempivoSensorSession(
         }
     }
 
+    suspend fun connect(qr: TempivoSensorQr, deviceId: String, bluetoothMac: String) {
+        connect(qr.serial, bluetoothMac, qr.pin, deviceId)
+    }
+
     suspend fun connect(qr: TempivoSensorQr) {
-        connect(qr.serial, qr.bluetoothMac, qr.pin, qr.sessionType)
+        connect(qr.serial, qr.bluetoothMac, qr.pin, qr.deviceId)
     }
 
     suspend fun disconnect() {
@@ -100,6 +101,9 @@ class TempivoSensorSession(
         return runGatt { SensorBleRuntime.readCalibration(requireSession()) }
     }
 
+    fun connectBlocking(qr: TempivoSensorQr, deviceId: String, bluetoothMac: String) =
+        runBlocking { connect(qr, deviceId, bluetoothMac) }
+
     fun connectBlocking(qr: TempivoSensorQr) = runBlocking { connect(qr) }
 
     fun disconnectBlocking() = runBlocking { disconnect() }

package/dist/connect-helpers.d.ts

@@ -0,0 +1,52 @@
+import type { TempivoNativeMeasurement, TempivoSensorBeaconDevice } from './native-types.js';
+import type { TempivoSensorQr } from './session-types.js';
+/** Loose sticker QR parse (same shape as in-app `parseEfentoQrJson`). Returns null on invalid JSON. */
+export type ParsedSensorQrLoose = {
+    sn?: string;
+    pin?: string;
+    model?: string;
+    iccid?: string;
+};
+export type SensorStickerModel = 'HC5' | 'HC7';
+export type SensorBleConnectCredentials = {
+    resetCode?: number;
+    encryptionKey?: string;
+};
+/** PIN / reset code from sticker JSON (`pin` or `resetCode`, string or number). */
+export declare function pinFromSensorQrRecord(rec: Record<string, unknown>): string | undefined;
+/** Parse sticker QR JSON without throwing (invalid → null). */
+export declare function tryParseSensorQrJson(text: string): ParsedSensorQrLoose | null;
+/** Serial from QR scan payload (structured or raw JSON). 12 hex chars or null. */
+export declare function serialHexFromSensorQrScan(data: string | {
+    sn?: string;
+    raw?: string;
+} | null | undefined): string | null;
+/**
+ * True when QR serial is missing/incomplete, or matches selected BLE serial.
+ * False when both are 12-hex and differ (wrong sticker for selected device).
+ */
+export declare function sensorQrSerialMatchesSelected(qrSerialHex: string | null | undefined, selectedSerial: string | null | undefined): boolean;
+/** Normalize sticker `model` to HC5/HC7, or null if missing/unknown. */
+export declare function normalizeSensorStickerModel(model: string | undefined | null): SensorStickerModel | null;
+/**
+ * Map label PIN to native connect credentials (resetCode + encryptionKey for 5–6 digit codes).
+ * Same rules as Tempivo app `resolveEfentoBleConnectCredentialsFromPin`.
+ */
+export declare function resolveSensorBleConnectCredentialsFromPin(pinOrCode: string | undefined | null): SensorBleConnectCredentials;
+export declare function buildSensorQrConnectJson(parts: {
+    serial: string;
+    pin: string;
+    model?: string;
+    deviceId?: string;
+}): string;
+/** Build connect JSON from a parsed QR (strict) or loose scan result. */
+export declare function sensorQrConnectJsonFromLoose(loose: ParsedSensorQrLoose, deviceId?: string): string | null;
+type ScanDevicePick = Pick<TempivoSensorBeaconDevice, 'serialNumber' | 'deviceId' | 'bluetoothMacAddress' | 'model' | 'telemetry'>;
+/** Draft QR JSON from a scan row (uses device model / FW hint, keeps existing PIN if provided). */
+export declare function draftSensorQrConnectJsonFromScanDevice(device: ScanDevicePick, pin?: string): string | null;
+/** Merge scan `deviceId` / MAC from a selected row into a parsed QR for connect. */
+export declare function mergeScanTargetIntoSensorQr(qr: TempivoSensorQr, device: ScanDevicePick | null | undefined): TempivoSensorQr;
+/** Parse QR text and attach scan target (deviceId, MAC) when a row is selected. */
+export declare function parseSensorQrForConnect(qrText: string, selectedDevice?: ScanDevicePick | null): TempivoSensorQr;
+export declare function formatSensorReadingLine(reading: Pick<TempivoNativeMeasurement, 'typeHex' | 'text'>): string;
+export {};