@tempivo/sensor-beacon 0.3.3 → 0.4.3

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,23 @@ 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.EfentoBluetooth
+import pl.efento.mobile.bluetooth.model.Device as EfentoDevice
+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 — same strategy as the Tempivo Capacitor app:
+ * alternate Efento SDK `deviceFlow()` with manufacturer `0x026C` adv-only windows.
  */
 class TempivoSensorBeaconScanner(
     context: Context,
@@ -35,31 +47,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 +89,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 = EfentoBluetooth.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: EfentoDevice) {
+        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 +205,70 @@ 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,
+            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/TempivoSensorQr.kt

@@ -7,7 +7,6 @@ data class TempivoSensorQr(
     val serial: String,
     val pin: String,
     val model: String?,
-    val sessionType: TempivoSensorSession.SessionType,
     val bluetoothMac: String,
 )
 
@@ -30,13 +29,13 @@ object TempivoSensorQrParser {
         }
     }
 
-    fun sessionTypeFromModel(model: String?): TempivoSensorSession.SessionType {
-        if (model.isNullOrBlank()) return TempivoSensorSession.SessionType.MODERN
+    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,12 +60,12 @@ 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)
         return TempivoSensorQr(
             serial = serial,
             pin = pin,
             model = model,
-            sessionType = sessionTypeFromModel(model),
             bluetoothMac = bluetoothMacFromSerial(hex),
         )
     }

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,12 @@ 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,7 +26,6 @@ class TempivoSensorSession(
         serial: String,
         bluetoothMac: String,
         pin: String,
-        sessionType: SessionType = SessionType.MODERN,
     ) {
         val pinInt =
             pin.trim().toIntOrNull()
@@ -48,7 +41,6 @@ class TempivoSensorSession(
                             serial = TempivoSensorQrParser.normalizeSerial(serial),
                             bluetoothMac = bluetoothMac,
                             pin = pinInt,
-                            legacy = sessionType == SessionType.LEGACY,
                         )
                     }
             }
@@ -64,7 +56,7 @@ class TempivoSensorSession(
     }
 
     suspend fun connect(qr: TempivoSensorQr) {
-        connect(qr.serial, qr.bluetoothMac, qr.pin, qr.sessionType)
+        connect(qr.serial, qr.bluetoothMac, qr.pin)
     }
 
     suspend fun disconnect() {

package/dist/decoder.d.ts

@@ -11,5 +11,3 @@ export declare function splitSensorBeaconFrames(payload: Uint8Array): Uint8Array
 export declare function buildSensorBeaconReading(adv03: Uint8Array | null | undefined, adv04: Uint8Array | null | undefined, rawHex?: string): SensorBeaconReading | null;
 /** One-shot decode of manufacturer payload (after company id strip). */
 export declare function decodeSensorBeaconPayload(data: Uint8Array): SensorBeaconReading | null;
-/** FW 7+ → modern (`false`); FW 6-/5.x → legacy (`true`). */
-export declare function legacyHintFromFirmware(firmware: string | null | undefined): boolean | null;

package/dist/decoder.js

@@ -306,20 +306,3 @@ export function decodeSensorBeaconPayload(data) {
     const merged03 = adv03 ?? adv02;
     return buildSensorBeaconReading(merged03, adv04, bufferToHex(data));
 }
-/** FW 7+ → modern (`false`); FW 6-/5.x → legacy (`true`). */
-export function legacyHintFromFirmware(firmware) {
-    if (!firmware?.trim())
-        return null;
-    const t = firmware.trim();
-    if (/^FW 5/i.test(t))
-        return true;
-    const m = /^(\d+)\.\d+/.exec(t);
-    if (!m)
-        return null;
-    const major = parseInt(m[1], 10);
-    if (major >= 7)
-        return false;
-    if (major >= 1)
-        return true;
-    return null;
-}

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { dataViewToUint8Array, manufacturerPayloadsFromScanRecordBytes, normaliz
 export { MEASURE_SPECS, type MeasureSpec } from './measure-specs.js';
 export { createSensorBeaconFrameCache, type SensorBeaconFrameCache, type SensorBeaconMeasurement, type SensorBeaconReading, } from './types.js';
 export { TempivoSensorError, type TempivoSensorErrorCode } from './errors.js';
-export { DEFAULT_SENSOR_MODEL, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { DEFAULT_SENSOR_MODEL, assertSupportedSensorModel, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
 export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
 export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
 export type { TempivoSchedule, TempivoScheduleAlways, TempivoScheduleWeek, TempivoSensorCalibration, TempivoSensorConfiguration, TempivoSensorQr, TempivoSensorSessionType, TempivoTemperatureAlert, TempivoTemperatureChannel, TempivoTemperatureMaxAlert, TempivoTemperatureMinAlert, TempivoTemperatureRangeAlert, TempivoTriggerTransmissionResult, } from './session-types.js';

package/dist/index.js

@@ -4,7 +4,7 @@ export { dataViewToUint8Array, manufacturerPayloadsFromScanRecordBytes, normaliz
 export { MEASURE_SPECS } from './measure-specs.js';
 export { createSensorBeaconFrameCache, } from './types.js';
 export { TempivoSensorError } from './errors.js';
-export { DEFAULT_SENSOR_MODEL, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { DEFAULT_SENSOR_MODEL, assertSupportedSensorModel, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
 export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
 export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
 export { addDeviceFoundListener, connect, disconnect, getCalibration, getConfiguration, isNativeSensorBeaconAvailable, isScanning, requestPermissions, setConfigurationJson, startScan, stopScan, triggerTransmission, } from './native-bridge.js';

package/dist/native-module.js

@@ -50,7 +50,11 @@ export function isScanning() {
     return getNative().isScanning();
 }
 export function addDeviceFoundListener(listener) {
-    return getNative().addListener('onDeviceFound', listener);
+    const native = getNative();
+    if (typeof native.addListener !== 'function') {
+        throw new TempivoSensorError('runtimeUnavailable', 'Native scan events are unavailable in this build.');
+    }
+    return native.addListener('onDeviceFound', listener);
 }
 export async function connect(qr) {
     await ensureBlePermission();

package/dist/qr.d.ts

@@ -2,9 +2,10 @@ import type { TempivoSensorQr, TempivoSensorSessionType } from './session-types.
 export declare function normalizeSensorSerial(value: string): string;
 /** `282C024F0012` → `28:2C:02:4F:00:12`. */
 export declare function bluetoothMacFromSerial(serial: string): string;
-/** BLE default when QR omits `model`. Firmware 6.x still selects legacy. */
+/** BLE default when QR omits `model`. */
 export declare const DEFAULT_SENSOR_MODEL = "HC7";
-export declare function sessionTypeFromModel(model: string | undefined | null): TempivoSensorSessionType;
+export declare function assertSupportedSensorModel(model: string): void;
+export declare function sessionTypeFromModel(_model: string | undefined | null): TempivoSensorSessionType;
 /**
  * 3-byte big-endian numeric PIN for GATT command payloads that check a reset code
  * (`setConfiguration`, trigger, and many other privileged writes).

package/dist/qr.js

@@ -13,14 +13,15 @@ export function bluetoothMacFromSerial(serial) {
         parts.push(key.slice(i, i + 2));
     return parts.join(':');
 }
-/** BLE default when QR omits `model`. Firmware 6.x still selects legacy. */
+/** BLE default when QR omits `model`. */
 export const DEFAULT_SENSOR_MODEL = 'HC7';
-export function sessionTypeFromModel(model) {
-    if (model == null || model.trim() === '')
-        return 'modern';
+export function assertSupportedSensorModel(model) {
     const m = model.trim().toUpperCase().replace(/-/g, '');
-    if (m === 'HC5' || m.startsWith('6'))
-        return 'legacy';
+    if (m === 'HC5') {
+        throw new TempivoSensorError('invalidQr', 'HC5 is not supported by the partner SDK. Use HC7 sensors.');
+    }
+}
+export function sessionTypeFromModel(_model) {
     return 'modern';
 }
 /**
@@ -80,6 +81,7 @@ export function parseSensorQrJson(text) {
     }
     const rawModel = typeof rec.model === 'string' ? rec.model.trim() : '';
     const model = rawModel || DEFAULT_SENSOR_MODEL;
+    assertSupportedSensorModel(model);
     return {
         serial,
         pin,

package/dist/react-native.d.ts

@@ -1 +1,24 @@
-export * from './index.js';
+export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+export { ingestManufacturerPayload } from './ingest.js';
+export { dataViewToUint8Array, manufacturerPayloadsFromScanRecordBytes, normalizeManufacturerBytes } from './normalize.js';
+export { MEASURE_SPECS, type MeasureSpec } from './measure-specs.js';
+export { createSensorBeaconFrameCache, type SensorBeaconFrameCache, type SensorBeaconMeasurement, type SensorBeaconReading, } from './types.js';
+export { TempivoSensorError, type TempivoSensorErrorCode } from './errors.js';
+export { DEFAULT_SENSOR_MODEL, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
+export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
+export type { TempivoSchedule, TempivoScheduleAlways, TempivoScheduleWeek, TempivoSensorCalibration, TempivoSensorConfiguration, TempivoSensorQr, TempivoSensorSessionType, TempivoTemperatureAlert, TempivoTemperatureChannel, TempivoTemperatureMaxAlert, TempivoTemperatureMinAlert, TempivoTemperatureRangeAlert, TempivoTriggerTransmissionResult, } from './session-types.js';
+export type { TempivoDeviceFoundSubscription, TempivoNativeCalibration, TempivoNativeMeasurement, TempivoNativePermissionResponse, TempivoNativePermissionStatus, TempivoNativeQr, TempivoNativeTelemetry, TempivoSensorBeaconDevice, } from './native-types.js';
+import * as native from './native-module.js';
+export declare const isNativeSensorBeaconAvailable: typeof native.isNativeSensorBeaconAvailable;
+export declare const requestPermissions: typeof native.requestPermissions;
+export declare const startScan: typeof native.startScan;
+export declare const stopScan: typeof native.stopScan;
+export declare const isScanning: typeof native.isScanning;
+export declare const addDeviceFoundListener: typeof native.addDeviceFoundListener;
+export declare const connect: typeof native.connect;
+export declare const disconnect: typeof native.disconnect;
+export declare const getConfiguration: typeof native.getConfiguration;
+export declare const setConfigurationJson: typeof native.setConfigurationJson;
+export declare const triggerTransmission: typeof native.triggerTransmission;
+export declare const getCalibration: typeof native.getCalibration;

package/dist/react-native.js

@@ -1 +1,22 @@
-export * from './index.js';
+export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+export { ingestManufacturerPayload } from './ingest.js';
+export { dataViewToUint8Array, manufacturerPayloadsFromScanRecordBytes, normalizeManufacturerBytes } from './normalize.js';
+export { MEASURE_SPECS } from './measure-specs.js';
+export { createSensorBeaconFrameCache, } from './types.js';
+export { TempivoSensorError } from './errors.js';
+export { DEFAULT_SENSOR_MODEL, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
+export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
+import * as native from './native-module.js';
+export const isNativeSensorBeaconAvailable = native.isNativeSensorBeaconAvailable;
+export const requestPermissions = native.requestPermissions;
+export const startScan = native.startScan;
+export const stopScan = native.stopScan;
+export const isScanning = native.isScanning;
+export const addDeviceFoundListener = native.addDeviceFoundListener;
+export const connect = native.connect;
+export const disconnect = native.disconnect;
+export const getConfiguration = native.getConfiguration;
+export const setConfigurationJson = native.setConfigurationJson;
+export const triggerTransmission = native.triggerTransmission;
+export const getCalibration = native.getCalibration;

package/dist/session-types.d.ts

@@ -1,4 +1,5 @@
-export type TempivoSensorSessionType = 'modern' | 'legacy';
+/** Partner SDK: modern GATT only (HC7 / firmware 7+). */
+export type TempivoSensorSessionType = 'modern';
 export type TempivoTemperatureChannel = 'ambient' | 'probe';
 export type TempivoTemperatureRangeAlert = {
     type: 'range';
@@ -54,8 +55,9 @@ export type TempivoSensorConfiguration = {
 export type TempivoSensorQr = {
     serial: string;
     pin: string;
-    /** Optional sticker field. Firmware from the last scan wins. Firmware 7+ is modern GATT. */
+    /** Optional sticker field. Defaults to HC7. HC5 is rejected. */
     model?: string;
+    /** Always `modern` (HC7 GATT). */
     sessionType: TempivoSensorSessionType;
     bluetoothMac: string;
 };

package/ios/Sources/TempivoSensorBeacon/TempivoSensorQr.swift

@@ -29,13 +29,15 @@ public enum TempivoSensorQrParser {
 
     public static let defaultModel = "HC7"
 
-    public static func sessionType(fromModel model: String?) -> TempivoSensorSessionType {
-        guard let model, !model.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
-            return .modern
-        }
+    public static func assertSupportedModel(_ model: String) throws {
         let m = model.trimmingCharacters(in: .whitespacesAndNewlines).uppercased().replacingOccurrences(of: "-", with: "")
-        if m == "HC5" || m.hasPrefix("6") { return .legacy }
-        return .modern
+        if m == "HC5" {
+            throw TempivoSensorError(.invalidQr, "HC5 is not supported by the partner SDK. Use HC7 sensors.")
+        }
+    }
+
+    public static func sessionType(fromModel _: String?) -> TempivoSensorSessionType {
+        .modern
     }
 
     public static func parse(_ json: String) throws -> TempivoSensorQr {
@@ -59,12 +61,13 @@ public enum TempivoSensorQrParser {
         }
         let rawModel = (obj["model"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
         let model = rawModel.isEmpty ? defaultModel : rawModel
+        try assertSupportedModel(model)
         let hex = serial.count == 12 ? serial : String(serial.suffix(12))
         return TempivoSensorQr(
             serial: serial,
             pin: pin,
             model: model,
-            sessionType: sessionType(fromModel: model),
+            sessionType: .modern,
             bluetoothMac: try bluetoothMacFromSerial(hex)
         )
     }