@tempivo/sensor-beacon 0.1.1 → 0.2.0

package/README.md

@@ -1,129 +1,245 @@
 # @tempivo/sensor-beacon
 
-Tempivo partner SDK for **BLE advertising** from Tempivo sensors (manufacturer id **0x026C**). **No GATT connection.**
+Tempivo partner SDK for sensors over BLE. Advertisement decode (manufacturer id **0x026C**) plus GATT session for alert rules, an immediate uplink, and laboratory calibration date.
 
-One npm package:
+```bash
+npm install @tempivo/sensor-beacon
+```
 
 | Path | Use |
 |------|-----|
-| `dist/` | Node / TypeScript decoder |
-| `android/` + `dist/tempivo-sensor-beacon.aar` | Android scan + decode |
-| `ios/` | iOS Swift Package (scan + decode) |
+| `dist/` | Node / TypeScript: advertising decode, QR parse, config JSON |
+| `android/` + `dist/tempivo-sensor-beacon.aar` | Android scan + GATT |
+| `ios/` | iOS Swift Package (scan + session) |
 
-```bash
-npm install @tempivo/sensor-beacon
-```
+GATT runs on a phone (Android / iOS), not in Node. Always pass the sticker PIN to `connect`. Wrong PIN maps to `invalidPin`.
 
-## Node / TypeScript
+## QR object
 
-Node.js 18+. Import from the package root:
+Sticker QR is JSON. Parse with `parseSensorQrJson` (Node) or `TempivoSensorQrParser.parse` (Android / iOS).
+
+```json
+{ "sn": "282C024F0012", "pin": "111111", "model": "HC7" }
+```
 
 ```ts
-import {
-  TEMPVO_SENSOR_MANUFACTURER_ID,
-  normalizeManufacturerBytes,
-  decodeSensorBeaconPayload,
-} from '@tempivo/sensor-beacon';
+const qr = parseSensorQrJson(stickerQrText);
+```
 
-const reading = decodeSensorBeaconPayload(normalizeManufacturerBytes(rawBytes));
+| 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. |
+| `sessionType` | `modern` \| `legacy` | GATT path. HC7 / firmware 7+ is `modern`. HC5 / firmware 6.x is `legacy`. |
+| `bluetoothMac` | string | BLE MAC with colons, derived from `serial`. |
+
+## Config JSON (same as Cellular API)
+
+`setConfiguration` / `getConfiguration` use the same `temperatureAlerts` + `schedule` shape as `POST /api/v1/devices/config-profiles`.
+
+```json
+{
+  "schedule": { "always": true },
+  "temperatureAlerts": [
+    {
+      "type": "range",
+      "channel": "probe",
+      "lowC": -30,
+      "highC": -10,
+      "hysteresisC": 0.5,
+      "transmitOnBreach": true,
+      "transmitOnReturn": true
+    }
+  ]
+}
 ```
 
-Many stacks return manufacturer bytes **without** the 2-byte company id (`6C 02`). Use `normalizeManufacturerBytes` when needed.
+**Root**
+
+| Field | Meaning |
+|-------|---------|
+| `temperatureAlerts` | Alert list. Empty array is valid (no temperature alerts). |
+| `schedule` | When alerts are active. `{ "always": true }` is 24/7. |
+
+Ignored over BLE: `slug`, `name`, `measurementIntervalMinutes`, `transmissionIntervalSeconds`. Do not pass `GET /devices/{serial}/config` (`alarmRules`).
+
+**Each `temperatureAlerts[]` item**
+
+| Field | Meaning |
+|-------|---------|
+| `type` | `range` (band), `min` (below), or `max` (above). |
+| `channel` | `ambient` or `probe`. |
+| `lowC` / `highC` | Inclusive band for `type: "range"`. |
+| `minC` | Threshold for `type: "min"`. |
+| `maxC` | Threshold for `type: "max"`. |
+| `hysteresisC` | Degrees of hysteresis. Omitted: **1**. |
+| `transmitOnBreach` | Uplink when the alert trips. Omitted: **true**. |
+| `transmitOnReturn` | Extra uplink when temp returns inside a `range`. Omitted: **true**. Range only. |
 
-### Frame cache (`0x03` + `0x04`)
+**`schedule` weekday window** (instead of `always`)
 
-FW6 devices split meta (advertisement) and measurements (scan response):
+| Field | Meaning |
+|-------|---------|
+| `weekdays` | **0 = Monday** … **6 = Sunday**. |
+| `from` / `to` | 24h `HH:MM`. |
+| `utcOffsetMinutes` | Offset from UTC for `from` / `to`. |
+
+## Fetch a profile, apply over BLE
+
+`GET /api/v1/devices/config-profiles/{slug}` returns `{ "profile": { … } }`. Pass the GET body or `profile` to `setConfigurationJson`.
 
 ```ts
-import {
-  createSensorBeaconFrameCache,
-  ingestManufacturerPayload,
-  buildSensorBeaconReading,
-  macKeyFromAddress,
-} from '@tempivo/sensor-beacon';
+import { parseSensorQrJson, configurationFromApiProfile } from '@tempivo/sensor-beacon';
+
+const qr = parseSensorQrJson(stickerQrText);
+const res = await fetch(
+  `https://app.tempivo.com/api/v1/devices/config-profiles/${slug}`,
+  { headers: { Authorization: `Bearer ${apiKey}` } }
+);
+const body = await res.json();
+const cfg = configurationFromApiProfile(body); // or body.profile
+```
+
+On the phone, after `connect(qr)`:
 
-const cache = createSensorBeaconFrameCache();
-const macKey = macKeyFromAddress('28:2C:02:4F:00:12');
-ingestManufacturerPayload(advPayload, macKey, cache);
-ingestManufacturerPayload(scanPayload, macKey, cache);
-const reading = buildSensorBeaconReading(cache.last03.get(macKey), cache.last04.get(macKey));
+```kotlin
+session.setConfigurationJson(profileJson) // GET body or profile object
+session.triggerTransmission()
 ```
 
-### TypeScript API
+BLE does not write measurement interval, transmission interval, server, APN, name, or token.
 
-| Export | Purpose |
-|--------|---------|
-| `TEMPVO_SENSOR_MANUFACTURER_ID` | BLE company id `0x026c` |
-| `normalizeManufacturerBytes` | Strip company id prefix when present |
-| `decodeSensorBeaconPayload` | One-shot decode |
-| `ingestManufacturerPayload` | Update frame cache |
-| `buildSensorBeaconReading` | Merge cached frames |
-| `SensorBeaconReading` | Parsed device + measurements |
+## Node / TypeScript helpers
 
-Measurement types **0x01–0x22** decode to human-readable `text` on each slot.
+```ts
+import {
+  normalizeManufacturerBytes,
+  decodeSensorBeaconPayload,
+  parseSensorQrJson,
+  parseSensorConfigurationJson,
+} from '@tempivo/sensor-beacon';
 
-## Android
+const qr = parseSensorQrJson('{"sn":"282C024F0012","pin":"111111","model":"HC7"}');
+const reading = decodeSensorBeaconPayload(normalizeManufacturerBytes(advertisementBytes));
+const cfg = parseSensorConfigurationJson(/* config JSON above */);
+```
 
-Published artifact: `dist/tempivo-sensor-beacon.aar` (built before npm publish).
+Invalid QR or config throws `TempivoSensorError` (`invalidQr`, `invalidPin`, `invalidConfig`).
+
+## Android (GATT)
+
+`connect` / `setConfigurationJson` / `triggerTransmission` are `suspend`. Request `BLUETOOTH_SCAN` and `BLUETOOTH_CONNECT` (API 31+) or location on older APIs.
 
 ```kotlin
-// app/build.gradle.kts
-dependencies {
-    implementation(
-        files(
-            "${rootProject.projectDir}/../node_modules/@tempivo/sensor-beacon/dist/tempivo-sensor-beacon.aar",
-        ),
-    )
+val qr = TempivoSensorQrParser.parse(stickerQrText)
+val session = TempivoSensorSession(context)
+
+session.connect(qr)
+try {
+    session.setConfigurationJson(profileJson)
+    val trigger = session.triggerTransmission()
+    val applied = session.getConfiguration()
+    val cal = session.getCalibration()
+} finally {
+    session.disconnect()
 }
 ```
 
-Adjust the path to your `node_modules` layout.
+**`triggerTransmission()`**
 
-```kotlin
-import com.tempivo.sensor.beacon.TempivoSensorBeaconScanner
+| Field | Meaning |
+|-------|---------|
+| `ok` | Device accepted the uplink request. |
+| `supported` | Firmware implements the command. `false` is not an error. |
 
-val scanner = TempivoSensorBeaconScanner(context)
-scanner.startScan { device ->
-    // device.serialNumber, device.rssi, device.telemetry, device.summary
-}
-```
+**`getCalibration()`**
 
-Declare and request `BLUETOOTH_SCAN` (API 31+) or location permissions for legacy APIs.
+| Field | Meaning |
+|-------|---------|
+| `laboratoryCalibrationDate` | ISO date (`YYYY-MM-DD`), or null if unset. |
+| `laboratoryCalibrationTimestamp` | Same instant as unix seconds, or null. No expiry field on the device. |
 
-## iOS
+## iOS (GATT)
 
-1. **File → Add Package Dependencies… → Add Local…**
-2. Path: `node_modules/@tempivo/sensor-beacon/ios`
-3. Add product **TempivoSensorBeacon**
-4. Set **`NSBluetoothAlwaysUsageDescription`** in Info.plist
+Needs a physical device and the native `TempivoSensorBridge` XCFramework (`scripts/build-ios-bridge.sh`). Set **`NSBluetoothAlwaysUsageDescription`** in Info.plist. Simulator can scan advertisements only.
 
 ```swift
-import TempivoSensorBeacon
+let qr = try TempivoSensorQrParser.parse(stickerQrText)
+let session = TempivoSensorSession()
+try session.connect(qr: qr)
+defer { session.disconnect() }
+try session.setConfigurationJson(profileJson)
+_ = try session.triggerTransmission()
+let applied = try session.getConfiguration()
+let cal = try session.getCalibration()
+```
 
-final class ScanHost: NSObject, TempivoSensorBeaconScannerDelegate {
-    private let scanner = TempivoSensorBeaconScanner()
+## Advertising (no pairing)
 
-    override init() {
-        super.init()
-        scanner.delegate = self
-    }
+Filter manufacturer data on company id **0x026C**. Use **active scanning** so scan-response packets arrive. Product model is **not** in the broadcast. Connect uses QR `model` (HC7 is modern GATT).
+
+```kotlin
+val scanner = TempivoSensorBeaconScanner(context)
+scanner.startScan { device ->
+    Log.d("scan", "${device.serialNumber} rssi=${device.rssi} ${device.summary}")
+}
+```
 
-    func start() { scanner.startScanning() }
+**Android `TempivoSensorBeaconDevice`**
+
+| Field | Meaning |
+|-------|---------|
+| `deviceId` | Android BLE address. Often randomized. Not the sticker serial. |
+| `bluetoothMacAddress` | MAC from the advertisement, with colons. |
+| `serialNumber` | 12 hex chars from advertisement frame `0x03`. Same as QR `sn`. |
+| `rssi` | Signal strength in dBm. |
+| `summary` | Short display line. After scan response: measurement texts joined with ` · `. Before that: serial, or `Adv OK. Wait for scan response (measurements).` |
+| `telemetry` | Decoded frames `0x03` + `0x04`, or null until enough bytes arrive. |
+
+**`telemetry` (Android) / `reading` (iOS and Node)**
+
+| Field | Meaning |
+|-------|---------|
+| `firmware` | `major.minor.patch` from the advertisement, e.g. `7.3.4`. |
+| `batteryOk` | Battery status flag from the advertisement. |
+| `encryptionEnabled` | Advertisement payload encryption flag. |
+| `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 from the advertisement, in seconds. |
+| `readings` | Decoded scan-response slots (see below). |
+| `readingsCount` | Number of measurement slots. |
+| `summary` | Same short line as on the device object. |
+| `measurementCounter` | Counter from frame `0x03`, or null. |
+
+Node also exposes `serialMac`, `temperatures[]`, `humidity`, and `rawHex`.
+
+**Each `readings[]` / `measurements[]` slot**
+
+| Field | Meaning |
+|-------|---------|
+| `typeHex` | Slot type, e.g. `0x01` temperature, `0x02` humidity. |
+| `raw24` | Undecoded 24-bit payload. |
+| `text` | Display value with unit, e.g. `21.8 °C`. No type name in the string. |
+| `temperatureC` / `humidityPct` | Node only: numeric value when the slot is that type. |
+
+iOS `SensorBeaconDiscovery` has `deviceId`, `rssi`, `serialNumber`, `bluetoothMacAddress`, and `reading` (same telemetry fields).
 
-    func sensorBeaconScanner(_ scanner: TempivoSensorBeaconScanner, didDiscover discovery: SensorBeaconDiscovery) {
-        print(discovery.serialNumber ?? discovery.deviceId, discovery.reading?.summary ?? "")
-    }
+```swift
+func sensorBeaconScanner(_ scanner: TempivoSensorBeaconScanner, didDiscover discovery: SensorBeaconDiscovery) {
+    print(discovery.serialNumber ?? "", discovery.rssi, discovery.reading?.summary ?? "")
 }
 ```
 
-Requires iOS 15+. Use a physical device for BLE.
+## Errors
+
+Native GATT maps to: `invalidPin`, `invalidQr`, `invalidConfig`, `notConnected`, `unsupportedCommand`, `connectFailed`, `runtimeUnavailable`, `unknown`.
 
-## Build locally
+## Tests
 
 ```bash
-npm run build:ts          # dist/ only
-npm run build:android     # requires Android SDK
-npm run build:all         # both
+npm run test:unit
 ```
 
 ## License

package/android/library/build.gradle

@@ -24,4 +24,7 @@ android {
 
 dependencies {
     implementation "androidx.core:core-ktx:1.17.0"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2"
+    implementation "pl.efento.mobile:bluetooth:2.3.0"
 }

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

@@ -0,0 +1,279 @@
+package com.tempivo.sensor.beacon
+
+import pl.efento.mobile.bluetooth.model.sensor.Action
+import pl.efento.mobile.bluetooth.model.sensor.DisabledCondition
+import pl.efento.mobile.bluetooth.model.sensor.HighThresholdCondition
+import pl.efento.mobile.bluetooth.model.sensor.LogicOperator
+import pl.efento.mobile.bluetooth.model.sensor.LogicOperatorCondition
+import pl.efento.mobile.bluetooth.model.sensor.LogicOperatorConditionParameters
+import pl.efento.mobile.bluetooth.model.sensor.LowThresholdCondition
+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.TemperatureLowHighThresholdConditionParameters
+import pl.efento.mobile.bluetooth.model.sensor.TriggeringMode
+
+/**
+ * Compile Cellular API `temperatureAlerts` + `schedule` into device rules.
+ * Range + `transmitOnReturn` uses the same OR layout as POST /devices/config-profiles.
+ */
+internal object PartnerBleRules {
+    fun compile(cfg: TempivoSensorConfiguration): Pair<List<Rule>, List<RuleCalendar>> {
+        val rules = MutableList(12) { i ->
+            Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION)
+        }
+        val used = BooleanArray(12)
+        val returnLowSlots = mutableListOf<Int>()
+
+        for (alert in cfg.temperatureAlerts) {
+            val channel = if (alert.channel == "probe") 3 else 1
+            val hyst = alert.hysteresisC ?: 1.0
+            when (alert.type) {
+                "min" -> {
+                    val slot = findFree(used) ?: continue
+                    val t = alert.minC ?: continue
+                    val action = if (alert.transmitOnBreach) Action.TRIGGER_TRANSMISSION_WITH_ACK else Action.NO_ACTION
+                    putThreshold(rules, slot, channel, low = true, t, hyst, action)
+                    used[slot] = true
+                }
+                "max" -> {
+                    val slot = findFree(used) ?: continue
+                    val t = alert.maxC ?: continue
+                    val action = if (alert.transmitOnBreach) Action.TRIGGER_TRANSMISSION_WITH_ACK else Action.NO_ACTION
+                    putThreshold(rules, slot, channel, low = false, t, hyst, action)
+                    used[slot] = true
+                }
+                "range" -> {
+                    val low = alert.lowC ?: continue
+                    val high = alert.highC ?: continue
+                    val pair = findPair(used) ?: continue
+                    val ret = alert.transmitOnReturn
+                    val action =
+                        when {
+                            ret -> Action.NO_ACTION
+                            alert.transmitOnBreach -> Action.TRIGGER_TRANSMISSION_WITH_ACK
+                            else -> Action.NO_ACTION
+                        }
+                    putThreshold(rules, pair, channel, low = true, low, hyst, action)
+                    putThreshold(rules, pair + 1, channel, low = false, high, hyst, action)
+                    used[pair] = true
+                    used[pair + 1] = true
+                    if (ret) returnLowSlots.add(pair)
+                }
+            }
+        }
+
+        for (lowSlot in returnLowSlots) {
+            val logicSlot = findFree(used) ?: break
+            rules[logicSlot] =
+                Rule(
+                    logicSlot + 1,
+                    emptySet(),
+                    LogicOperatorCondition(
+                        LogicOperatorConditionParameters(
+                            LogicOperator.OR,
+                            setOf(lowSlot + 1, lowSlot + 2),
+                            emptySet(),
+                            0,
+                            0,
+                        ),
+                    ),
+                    Action.TRIGGER_TRANSMISSION_WITH_ACK,
+                )
+            used[logicSlot] = true
+        }
+
+        val active = rules.filter { it.condition !is DisabledCondition }.map { it.id }.toSet()
+        val calendars = MutableList(6) { i ->
+            RuleCalendar(i + 1, emptySet(), RuleCalendar.Type.Disabled)
+        }
+        if (active.isNotEmpty()) {
+            calendars[0] = RuleCalendar(1, active, weeklyType(cfg.schedule))
+        }
+        return rules to calendars
+    }
+
+    fun decompile(cfg: SensorConfiguration): TempivoSensorConfiguration {
+        val padded = MutableList(12) { i ->
+            cfg.rules.orEmpty().getOrNull(i)
+                ?: Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION)
+        }
+        val orRefs = orSelectedPairs(padded)
+        val used = BooleanArray(12)
+        val alerts = mutableListOf<TempivoTemperatureAlert>()
+
+        for (i in 0..10) {
+            if (used[i] || used[i + 1]) continue
+            val low = padded[i]
+            val high = padded[i + 1]
+            if (low.condition !is LowThresholdCondition || high.condition !is HighThresholdCondition) continue
+            val lowCh = channelOf(low) ?: continue
+            val highCh = channelOf(high) ?: continue
+            if (lowCh != highCh) continue
+            val lowP = (low.condition as LowThresholdCondition).conditionParameters
+            val highP = (high.condition as HighThresholdCondition).conditionParameters
+            val hasReturn = orRefs.any { it.first == i + 1 && it.second == i + 2 }
+            val breachOnly =
+                !hasReturn && (low.action != Action.NO_ACTION || high.action != Action.NO_ACTION)
+            alerts.add(
+                TempivoTemperatureAlert(
+                    type = "range",
+                    channel = lowCh,
+                    lowC = lowP.thresholdValue.toDouble(),
+                    highC = highP.thresholdValue.toDouble(),
+                    hysteresisC = lowP.hysteresisValue?.toDouble() ?: 1.0,
+                    transmitOnBreach = hasReturn || breachOnly,
+                    transmitOnReturn = hasReturn,
+                ),
+            )
+            used[i] = true
+            used[i + 1] = true
+        }
+
+        for (i in 0 until 12) {
+            if (used[i]) continue
+            val r = padded[i]
+            when (val c = r.condition) {
+                is LowThresholdCondition -> {
+                    val ch = channelOf(r) ?: continue
+                    alerts.add(
+                        TempivoTemperatureAlert(
+                            type = "min",
+                            channel = ch,
+                            minC = c.conditionParameters.thresholdValue.toDouble(),
+                            hysteresisC = c.conditionParameters.hysteresisValue?.toDouble() ?: 1.0,
+                            transmitOnBreach = r.action != Action.NO_ACTION,
+                        ),
+                    )
+                    used[i] = true
+                }
+                is HighThresholdCondition -> {
+                    val ch = channelOf(r) ?: continue
+                    alerts.add(
+                        TempivoTemperatureAlert(
+                            type = "max",
+                            channel = ch,
+                            maxC = c.conditionParameters.thresholdValue.toDouble(),
+                            hysteresisC = c.conditionParameters.hysteresisValue?.toDouble() ?: 1.0,
+                            transmitOnBreach = r.action != Action.NO_ACTION,
+                        ),
+                    )
+                    used[i] = true
+                }
+                else -> Unit
+            }
+        }
+
+        return TempivoSensorConfiguration(alerts, decompileSchedule(cfg.ruleCalendars))
+    }
+
+    private fun orSelectedPairs(rules: List<Rule>): List<Pair<Int, Int>> {
+        val out = mutableListOf<Pair<Int, Int>>()
+        for (r in rules) {
+            val c = r.condition as? LogicOperatorCondition ?: continue
+            val p = c.conditionParameters
+            if (p.logicOperator != LogicOperator.OR) continue
+            val ids = p.selectedRules.sorted()
+            if (ids.size == 2) out.add(ids[0] to ids[1])
+        }
+        return out
+    }
+
+    private fun channelOf(rule: Rule): String? =
+        when {
+            rule.channels.contains(3) -> "probe"
+            rule.channels.contains(1) -> "ambient"
+            else -> null
+        }
+
+    private fun findPair(used: BooleanArray): Int? {
+        for (i in 0..10) {
+            if (!used[i] && !used[i + 1]) return i
+        }
+        return null
+    }
+
+    private fun findFree(used: BooleanArray): Int? {
+        for (i in 0 until 12) if (!used[i]) return i
+        return null
+    }
+
+    private fun putThreshold(
+        rules: MutableList<Rule>,
+        slot: Int,
+        channel: Int,
+        low: Boolean,
+        threshold: Double,
+        hyst: Double,
+        action: Action,
+    ) {
+        if (slot !in 0..11) return
+        val params =
+            TemperatureLowHighThresholdConditionParameters(
+                threshold,
+                hyst,
+                TriggeringMode.CONSECUTIVE_SAMPLES,
+                1,
+            )
+        val condition = if (low) LowThresholdCondition(params) else HighThresholdCondition(params)
+        rules[slot] = Rule(slot + 1, setOf(channel), condition, action)
+    }
+
+    private fun decompileSchedule(calendars: List<RuleCalendar>?): TempivoSchedule {
+        val weekly = calendars.orEmpty().map { it.type }.filterIsInstance<RuleCalendar.Type.Weekly>().firstOrNull()
+            ?: return TempivoSchedule(always = true)
+        val days = weekly.days.map { dayToPartnerIndex(it) }.sorted()
+        val always = days.size == 7 && weekly.fromTime == 0 && weekly.toTime >= 1439
+        return if (always) {
+            TempivoSchedule(always = true)
+        } else {
+            TempivoSchedule(
+                always = false,
+                weekdays = days,
+                from = TempivoSensorProfile.hhmmFromMinutes(weekly.fromTime),
+                to = TempivoSensorProfile.hhmmFromMinutes(weekly.toTime),
+                utcOffsetMinutes = weekly.timezoneOffset,
+            )
+        }
+    }
+
+    private fun weeklyType(schedule: TempivoSchedule): RuleCalendar.Type {
+        if (schedule.always) {
+            return RuleCalendar.Type.Weekly(
+                days = RuleCalendar.Type.Weekly.Day.entries.toSet(),
+                fromTime = 0,
+                toTime = 1439,
+                timezoneOffset = 0,
+            )
+        }
+        val days = schedule.weekdays.map { partnerIndexToDay(it) }.toSet()
+        return RuleCalendar.Type.Weekly(
+            days = days,
+            fromTime = TempivoSensorProfile.minutesFromHhmm(schedule.from ?: "00:00"),
+            toTime = TempivoSensorProfile.minutesFromHhmm(schedule.to ?: "23:59"),
+            timezoneOffset = schedule.utcOffsetMinutes,
+        )
+    }
+
+    private fun partnerIndexToDay(index: Int): RuleCalendar.Type.Weekly.Day =
+        when (index) {
+            0 -> RuleCalendar.Type.Weekly.Day.MONDAY
+            1 -> RuleCalendar.Type.Weekly.Day.TUESDAY
+            2 -> RuleCalendar.Type.Weekly.Day.WEDNESDAY
+            3 -> RuleCalendar.Type.Weekly.Day.THURSDAY
+            4 -> RuleCalendar.Type.Weekly.Day.FRIDAY
+            5 -> RuleCalendar.Type.Weekly.Day.SATURDAY
+            else -> RuleCalendar.Type.Weekly.Day.SUNDAY
+        }
+
+    private fun dayToPartnerIndex(day: RuleCalendar.Type.Weekly.Day): Int =
+        when (day) {
+            RuleCalendar.Type.Weekly.Day.MONDAY -> 0
+            RuleCalendar.Type.Weekly.Day.TUESDAY -> 1
+            RuleCalendar.Type.Weekly.Day.WEDNESDAY -> 2
+            RuleCalendar.Type.Weekly.Day.THURSDAY -> 3
+            RuleCalendar.Type.Weekly.Day.FRIDAY -> 4
+            RuleCalendar.Type.Weekly.Day.SATURDAY -> 5
+            RuleCalendar.Type.Weekly.Day.SUNDAY -> 6
+        }
+}