diff --git a/.claude/agent-memory/code-reviewer/MEMORY.md b/.claude/agent-memory/code-reviewer/MEMORY.md
index 1c627f918911..e01f7fc122fe 100644
--- a/.claude/agent-memory/code-reviewer/MEMORY.md
+++ b/.claude/agent-memory/code-reviewer/MEMORY.md
@@ -69,6 +69,8 @@
## See Also
-- `equil-migration.md` — detailed Equil Compose migration review (2026-03-09)
+- `carelevo-ble-transport-migration.md` — Carelevo BLE stack unification onto shared `BleTransport`
+ (Dana/Equil/Medtrum abstraction), Phase 1 adapter (`BleTransportGattConnection`) review (2026-07-08).
+ Confirms double-`@Singleton` DI pattern is intentional fleet convention (see Equil precedent), not a bug.
- Earlier migration reviews (NSClient, Tidepool, Wear, SMS, Preferences, EOPatch2): see conversation
history from 2026-03-01 and 2026-03-02.
diff --git a/.claude/agent-memory/code-reviewer/carelevo-ble-transport-migration.md b/.claude/agent-memory/code-reviewer/carelevo-ble-transport-migration.md
new file mode 100644
index 000000000000..8d43b8e25874
--- /dev/null
+++ b/.claude/agent-memory/code-reviewer/carelevo-ble-transport-migration.md
@@ -0,0 +1,81 @@
+# Carelevo BLE Transport Migration (Phase 1) — review notes (2026-07-08)
+
+## Architecture
+- Shared fleet abstraction: `core/interfaces/src/main/kotlin/app/aaps/core/interfaces/pump/ble/BleTransport.kt`
+ (`BleTransport`/`BleAdapter`/`BleScanner`/`BleGatt`/`BleTransportListener`). Used by Dana/Equil/Medtrum/Carelevo.
+ `BleGatt.writeCharacteristic(data)` and `.enableNotifications()` have NO uuid param — the transport
+ hardcodes a single write char + single notify char internally (one-service/one-write/one-notify patch
+ pump shape). `BleTransportListener.onCharacteristicWritten()` carries no status (unlike
+ `BluetoothGattCallback.onCharacteristicWrite`'s status int) — silently-dropped writes degrade to the
+ caller's own `withTimeout`, they don't fast-fail. Single listener via `setListener()` (last write wins,
+ no ownership enforcement).
+- `pump/carelevo/.../ble/gatt/BleTransportGattConnection.kt` is a NEW adapter bridging `BleTransport` to
+ carelevo's own pre-existing `GattConnection` contract, so `BleClientImpl` (coroutine correlation layer)
+ runs unchanged over either the old `AndroidGattConnection` (direct `BluetoothGatt` wrapper) or the new
+ shared-transport adapter. Mirrors `AndroidGattConnection`'s internals almost line for line (gattMutex +
+ 3x `@Volatile CompletableDeferred` for write/discovery/descriptor acks).
+- `pump/equil/.../ble/EquilBleTransportImpl.kt` is the template `CarelevoBleTransportImpl.kt` was cloned
+ from — near-identical structure (inner Adapter/Scanner/Gatt classes, `@Synchronized` gattCallback for
+ conn-state/svc-discovery/descriptor-write, unsynchronized for char write/read/changed).
+
+## Confirmed non-issues (checked against Equil precedent, don't re-flag)
+- **Double `@Singleton`** (class-level `@Singleton class XxxBleTransportImpl @Inject constructor` PLUS
+ `@Provides @Singleton fun provideXxxBleTransport(impl: XxxBleTransportImpl): XxxBleTransport = impl`)
+ is the established fleet pattern, not a bug. See `app/src/withPumps/kotlin/app/aaps/di/EquilModules.kt`
+ — this indirection exists so the app module can swap in an emulator transport
+ (`EquilEmulatorBleTransport`) at runtime while the impl module's own `@Module class` (non-abstract, so
+ no `@Binds`) still exposes the concrete singleton. Carelevo's `CarelevoBleModule.kt` binds it locally
+ instead (no emulator swap yet — KDoc says "a future emulator impl can be swapped in here"). Functionally
+ identical either way (Dagger caches per scoped binding, exactly one instance).
+- Synchronous listener callback firing INSIDE `gatt.writeCharacteristic()` on the not-connected path
+ (`listener?.onConnectionStateChanged(false)`) correctly aborts the just-registered `writeAck` deferred
+ with no deadlock risk — `completeExceptionally` never tries to reacquire `gattMutex`, and it all runs on
+ the same coroutine/call-stack that already holds the mutex from `writeCharacteristic`'s `withLock` block.
+ Verified via `BleTransportGattConnectionTest` `writeCharacteristic on a not-connected transport fast-
+ fails...` test — legit coverage, not trivially green.
+- `CarelevoBleTransportImpl.onServicesDiscovered` tightening the success condition to
+ `service != null && notifyChara != null && writeChara != null` (vs Equil's bare `service != null`) is a
+ **safety improvement**, not a regression — Equil's version can report false "success" if the service is
+ found but a characteristic UUID lookup inside it fails (firmware/UUID mismatch), only surfacing the real
+ failure later on the first write/enableNotifications call.
+- UUID role wiring verified correct: `BleEnvConfig`/`CarelevoConfig.kt` — service `e1b40001`, TX(notify)
+ `e1b40003` → `notifyChara`, RX(write) `e1b40002` → `writeChara`, CCCD `2902`. Matches Equil's analogous
+ NRF_UART_NOTIFY/NRF_UART_WRITE mapping.
+
+## Real findings (see full review text in conversation 2026-07-08 for details — recap here)
+- **High**: `BleTransportGattConnection` has no self-tracked "closed" flag. `close()` (lines ~122-130)
+ nulls the transport's listener slot (`transport.setListener(null)`) but a *subsequent* call to
+ `writeCharacteristic`/`discoverServices`/`enableNotifications` on the same (now-closed) adapter
+ re-acquires `gattMutex` uncontended, registers a fresh deferred, and calls into the transport — whose
+ not-connected fast-fail path (`listener?.onConnectionStateChanged(false)`) is now a silent no-op because
+ the listener is null. The deferred is never completed → hangs until the caller's own `withTimeout`
+ instead of failing fast. `AndroidGattConnection` avoids this by self-guarding with
+ `val g = gatt ?: throw GattWriteException(...)` at the top of every suspend op (checks its own nulled
+ `gatt` field, doesn't depend on a callback round-trip). Not yet reachable in production (adapter isn't
+ wired into any real call site yet — grep confirms only the test file constructs it), but must be fixed
+ before Phase 2 wiring.
+- **Medium-High (latent/Phase-2)**: Listener-slot ownership has zero enforcement. `CarelevoBleTransportImpl`
+ is `@Singleton`; `BleTransportGattConnection` is meant to be "one adapter instance owns the transport's
+ single listener slot for one connection lifecycle" (its own KDoc) but nothing asserts this. If a future
+ reconnect path ever constructs a new adapter without `close()`-ing the previous one first, the new
+ adapter's `init { transport.setListener(this) }` silently steals the slot; the old adapter's in-flight
+ deferred(s) hang until timeout with no error surfaced.
+- **Medium**: `writeCharacteristic(uuid, payload, withResponse)`'s `uuid` and `withResponse` params, and
+ `enableNotifications(uuid)`'s `uuid` param, are silently ignored by `BleTransportGattConnection` (the
+ underlying `BleGatt` interface has no per-uuid/write-type parameters — single hardcoded write/notify
+ char). No `require()` guard, no doc comment (contrast with the write-ack-status KDoc it does have).
+ A caller passing the wrong UUID (e.g. copy-paste bug) would silently "succeed" against the transport's
+ one real characteristic instead of erroring.
+- **Medium (pre-existing, not a regression)**: `writeAck`/`discoveryAck`/`descriptorAck` are bare mutable
+ fields, not per-op correlation tokens. A late/stale native ack for an aborted operation could in theory
+ complete a *different*, newer operation's deferred after `gattMutex` released and a new op started. This
+ risk is identical in `AndroidGattConnection` (same design) — not introduced by the new adapter, just
+ worth a shared follow-up someday.
+- **Test gaps**: no test for close()-then-reuse (would have caught the High finding above); no test for
+ double-close() idempotency (interface explicitly promises it); no test characterizing two adapters over
+ one transport clobbering the listener slot. Existing tests (register-before-write, synchronous not-
+ connected fast-fail, disconnect aborting in-flight write, full BleClient-over-adapter correlation
+ end-to-end via nested `scope.launch` + `runTest` virtual time) are legitimate, not trivially green.
+
+## See also
+- [MEMORY.md](MEMORY.md) main index
diff --git a/.idea/dictionaries/project_dictionary.xml b/.idea/dictionaries/project_dictionary.xml
index 5ab9ab769492..66d04ee06ef4 100644
--- a/.idea/dictionaries/project_dictionary.xml
+++ b/.idea/dictionaries/project_dictionary.xml
@@ -34,6 +34,7 @@
carbratio
carbs
carbsreq
+ carelevo
careportal
cctl
cellnovo
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 8325c3941f62..e7fdb42b2df8 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -234,6 +234,7 @@ dependencies {
// - :pump:combov2:comboctl is a support lib pulled in transitively by :pump:combov2
// buildFile.exists() skips the phantom :pump:omnipod container Gradle auto-creates from the
// nested :pump:omnipod:* includes (it has no build script / no consumable variant).
+ // :pump:carelevo is included automatically via this filter (present in settings.gradle).
val pumpExclusions = setOf(":pump:virtual", ":pump:combov2:comboctl")
rootProject.subprojects
.filter { it.path.startsWith(":pump:") && it.path !in pumpExclusions && it.buildFile.exists() }
@@ -301,4 +302,3 @@ if (!gitAvailable()) {
if (isMaster() && !allCommitted()) {
throw GradleException("There are uncommitted changes. Clone sources again as described in wiki and do not allow gradle update")
}
-
diff --git a/app/src/withPumps/kotlin/app/aaps/di/CarelevoModules.kt b/app/src/withPumps/kotlin/app/aaps/di/CarelevoModules.kt
new file mode 100644
index 000000000000..33a470ece046
--- /dev/null
+++ b/app/src/withPumps/kotlin/app/aaps/di/CarelevoModules.kt
@@ -0,0 +1,41 @@
+package app.aaps.di
+
+import app.aaps.core.interfaces.configuration.Config
+import app.aaps.core.interfaces.configuration.ExternalOptions
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.pump.carelevo.ble.CarelevoBleTransport
+import app.aaps.pump.carelevo.ble.CarelevoBleTransportImpl
+import app.aaps.pump.carelevo.emulator.CarelevoEmulatorBleTransport
+import app.aaps.pump.carelevo.emulator.CarelevoPumpEmulator
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+class CarelevoModules {
+
+ /**
+ * Selects the emulated patch over the real Bluetooth stack when the `emulate_carelevo` marker
+ * file is present, so the driver can be exercised end-to-end without patch hardware.
+ */
+ @Provides
+ @Singleton
+ fun provideCarelevoBleTransport(
+ config: Config,
+ carelevoBleTransportImpl: CarelevoBleTransportImpl,
+ aapsLogger: AAPSLogger
+ ): CarelevoBleTransport =
+ if (config.isEnabled(ExternalOptions.EMULATE_CARELEVO)) {
+ aapsLogger.debug(LTag.PUMPEMULATOR, "CareLevo emulator active — real Bluetooth is not used")
+ CarelevoEmulatorBleTransport(
+ emulator = CarelevoPumpEmulator(aapsLogger = aapsLogger),
+ aapsLogger = aapsLogger
+ )
+ } else {
+ carelevoBleTransportImpl
+ }
+}
diff --git a/app/src/withPumps/kotlin/app/aaps/di/PumpDriversModule.kt b/app/src/withPumps/kotlin/app/aaps/di/PumpDriversModule.kt
index b73ec1e8f5c8..61f8f46ed1a8 100644
--- a/app/src/withPumps/kotlin/app/aaps/di/PumpDriversModule.kt
+++ b/app/src/withPumps/kotlin/app/aaps/di/PumpDriversModule.kt
@@ -1,5 +1,6 @@
package app.aaps.di
+import app.aaps.pump.carelevo.di.CarelevoModule
import app.aaps.pump.common.di.PumpCommonModule
import app.aaps.pump.common.di.RileyLinkModule
import app.aaps.pump.diaconn.di.DiaconnG8Module
@@ -30,6 +31,8 @@ import info.nightscout.pump.combov2.di.ComboV2Module
MedtrumModule::class,
EquilModule::class,
EquilModules::class,
+ CarelevoModule::class,
+ CarelevoModules::class
]
)
@InstallIn(SingletonComponent::class)
diff --git a/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/ManufacturerType.kt b/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/ManufacturerType.kt
index 51daa400c22b..dee7202f0ecc 100644
--- a/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/ManufacturerType.kt
+++ b/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/ManufacturerType.kt
@@ -13,6 +13,7 @@ enum class ManufacturerType(val description: String) {
Ypsomed("Ypsomed"),
G2e("G2e"),
Eoflow("Eoflow"),
+ CareMedi("CareMedi"),
Equil("Equil");
}
\ No newline at end of file
diff --git a/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/PumpCapability.kt b/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/PumpCapability.kt
index 36dc916fa9a6..594fcebdb045 100644
--- a/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/PumpCapability.kt
+++ b/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/PumpCapability.kt
@@ -20,7 +20,7 @@ enum class PumpCapability {
DiaconnCapabilities(arrayOf(Capability.Bolus, Capability.ExtendedBolus, Capability.TempBasal, Capability.BasalProfileSet, Capability.Refill, Capability.ReplaceBattery, Capability.TDD, Capability.ManualTDDLoad)), //
EopatchCapabilities(arrayOf(Capability.Bolus, Capability.ExtendedBolus, Capability.TempBasal, Capability.BasalProfileSet, Capability.BasalRate30min)),
MedtrumCapabilities(arrayOf(Capability.Bolus, Capability.TempBasal, Capability.BasalProfileSet, Capability.BasalRate30min, Capability.TDD)), // Technically the pump supports ExtendedBolus, but not implemented (yet)
- ;
+ CarelevoCapabilities(arrayOf(Capability.Bolus, Capability.ExtendedBolus, Capability.TempBasal, Capability.BasalProfileSet, Capability.BasalRate30min));
var children: ArrayList = ArrayList()
diff --git a/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/PumpType.kt b/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/PumpType.kt
index 81d1d68283c2..9ff2c49e8d70 100644
--- a/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/PumpType.kt
+++ b/core/data/src/main/kotlin/app/aaps/core/data/pump/defs/PumpType.kt
@@ -457,6 +457,26 @@ enum class PumpType(
model = "untested",
parent = MEDTRUM_NANO
),
+
+ CAREMEDI_CARELEVO(
+ description = "Carelevo",
+ manufacturer = ManufacturerType.CareMedi,
+ model = "Carelevo",
+ bolusSize = 0.05,
+ specialBolusSize = null,
+ extendedBolusSettings = DoseSettings(0.05, 30, 8 * 60, 0.05, 25.0),
+ pumpTempBasalType = PumpTempBasalType.Absolute,
+ tbrSettings = DoseSettings(0.05, 30, 12 * 60, 0.0, 15.0),
+ specialBasalDurations = arrayOf(Capability.BasalRate_Duration30minAllowed),
+ baseBasalMinValue = 0.05,
+ baseBasalMaxValue = 15.0,
+ baseBasalStep = 0.05,
+ baseBasalSpecialSteps = null,
+ pumpCapability = PumpCapability.CarelevoCapabilities,
+ isPatchPump = true,
+ maxReservoirReading = 300,
+ source = Source.Carelevo
+ ),
EQUIL(
description = "Equil",
manufacturer = ManufacturerType.Equil,
@@ -511,7 +531,8 @@ enum class PumpType(
MDI,
VirtualPump,
Unknown,
- EQuil
+ EQuil,
+ Carelevo
}
companion object {
diff --git a/core/data/src/main/kotlin/app/aaps/core/data/ue/Sources.kt b/core/data/src/main/kotlin/app/aaps/core/data/ue/Sources.kt
index e0e79baf5805..398b54c5cc1c 100644
--- a/core/data/src/main/kotlin/app/aaps/core/data/ue/Sources.kt
+++ b/core/data/src/main/kotlin/app/aaps/core/data/ue/Sources.kt
@@ -83,6 +83,8 @@ enum class Sources {
Garmin,
Scene, //From Scene activation
Database, // for PersistenceLayer
+
+ Carelevo,
Unknown //if necessary
;
}
\ No newline at end of file
diff --git a/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/configuration/Config.kt b/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/configuration/Config.kt
index 78f4c3b10045..8bf82189a43c 100644
--- a/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/configuration/Config.kt
+++ b/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/configuration/Config.kt
@@ -35,6 +35,7 @@ enum class ExternalOptions(val filename: String) {
EMULATE_DANA_R("emulate_dana_r"),
EMULATE_DANA_R_KOREAN("emulate_dana_r_korean"),
EMULATE_DANA_R_V2("emulate_dana_r_v2"),
+ EMULATE_CARELEVO("emulate_carelevo"),
ENABLE_OMNIPOD_DRIFT_COMPENSATION("omnipod_drift_compensation"),
}
diff --git a/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/notifications/NotificationId.kt b/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/notifications/NotificationId.kt
index ff68f58543c3..797fb19b6c56 100644
--- a/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/notifications/NotificationId.kt
+++ b/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/notifications/NotificationId.kt
@@ -117,6 +117,9 @@ enum class NotificationId(
// Pump — Dana emulator
PUMP_EMULATOR_DISPLAY(INFO, PUMP),
+ // Pump — Carelevo
+ CARELEVO_PATCH_ALERT(URGENT, PUMP, allowMultiple = true),
+
// CGM
BG_READINGS_MISSED(URGENT, CGM),
SENSOR_CHANGE_DETECTED(NORMAL, CGM),
diff --git a/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/pump/ble/BleTransport.kt b/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/pump/ble/BleTransport.kt
index cf3aaec4ac8d..6415ceeadeab 100644
--- a/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/pump/ble/BleTransport.kt
+++ b/core/interfaces/src/main/kotlin/app/aaps/core/interfaces/pump/ble/BleTransport.kt
@@ -41,7 +41,8 @@ interface BleAdapter {
data class ScannedDevice(
val name: String,
val address: String,
- val scanRecordBytes: ByteArray? = null
+ val scanRecordBytes: ByteArray? = null,
+ val rssi: Int = Int.MIN_VALUE
)
interface BleScanner {
diff --git a/core/ui/src/main/kotlin/app/aaps/core/ui/compose/icons/IcPluginCarelevo.kt b/core/ui/src/main/kotlin/app/aaps/core/ui/compose/icons/IcPluginCarelevo.kt
new file mode 100644
index 000000000000..ea066e5108f9
--- /dev/null
+++ b/core/ui/src/main/kotlin/app/aaps/core/ui/compose/icons/IcPluginCarelevo.kt
@@ -0,0 +1,143 @@
+package app.aaps.core.ui.compose.icons
+
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.PathFillType
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.StrokeJoin
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.graphics.vector.path
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+
+/**
+ * Icon for CareLevo Pump Plugin.
+ *
+ * Single-color design using NonZero winding to create holes:
+ * CW outer body → filled border frame
+ * CCW inner panel → transparent window
+ * CCW connector dots (in border) → transparent holes
+ * CW lens circle → ring fill
+ * CCW lens center → transparent center of ring
+ * CW text bars → filled bars inside window
+ *
+ * Works correctly with any tint color (no multi-color tricks).
+ */
+val IcPluginCarelevo: ImageVector by lazy {
+ ImageVector.Builder(
+ name = "IcPluginCarelevo",
+ defaultWidth = 48.dp,
+ defaultHeight = 48.dp,
+ viewportWidth = 24f,
+ viewportHeight = 24f
+ ).apply {
+
+ // ── Combined body + all winding-based cutouts/fills ───────────────────
+ path(
+ fill = SolidColor(Color.Black),
+ fillAlpha = 1.0f,
+ stroke = null,
+ strokeAlpha = 1.0f,
+ strokeLineWidth = 1.0f,
+ strokeLineCap = StrokeCap.Butt,
+ strokeLineJoin = StrokeJoin.Miter,
+ strokeLineMiter = 1.0f,
+ pathFillType = PathFillType.NonZero
+ ) {
+ // ── 1. Outer device body (CW) ─ winding = +1 ──────────────────────
+ moveTo(5.9f, 4.5f)
+ lineTo(18.1f, 4.5f)
+ curveTo(20.5f, 4.5f, 22.5f, 6.5f, 22.5f, 8.9f)
+ lineTo(22.5f, 15.1f)
+ curveTo(22.5f, 17.5f, 20.5f, 19.5f, 18.1f, 19.5f)
+ lineTo(5.9f, 19.5f)
+ curveTo(3.5f, 19.5f, 1.5f, 17.5f, 1.5f, 15.1f)
+ lineTo(1.5f, 8.9f)
+ curveTo(1.5f, 6.5f, 3.5f, 4.5f, 5.9f, 4.5f)
+ close()
+
+ // ── 2. Inner panel (CCW) ─ cancels to 0 → transparent window ──────
+ // Start TL, go DOWN first (CCW in screen-Y-down coords)
+ moveTo(5.8f, 6.5f)
+ curveTo(4.58f, 6.5f, 3.6f, 7.48f, 3.6f, 8.7f)
+ lineTo(3.6f, 15.3f)
+ curveTo(3.6f, 16.52f, 4.58f, 17.5f, 5.8f, 17.5f)
+ lineTo(18.2f, 17.5f)
+ curveTo(19.42f, 17.5f, 20.4f, 16.52f, 20.4f, 15.3f)
+ lineTo(20.4f, 8.7f)
+ curveTo(20.4f, 7.48f, 19.42f, 6.5f, 18.2f, 6.5f)
+ close()
+
+ // ── 3. Connector dot holes (CCW, r=0.4) ─ transparent holes ───────
+ // isPositiveArc=false → CCW arc → creates hole
+ // Top connector (center 6.9, 5.8)
+ moveTo(7.3f, 5.8f)
+ arcToRelative(0.4f, 0.4f, 0f, isMoreThanHalf = true, isPositiveArc = false, dx1 = -0.8f, dy1 = 0f)
+ arcToRelative(0.4f, 0.4f, 0f, isMoreThanHalf = true, isPositiveArc = false, dx1 = 0.8f, dy1 = 0f)
+ // Bottom connector (center 6.9, 18.3)
+ moveTo(7.3f, 18.3f)
+ arcToRelative(0.4f, 0.4f, 0f, isMoreThanHalf = true, isPositiveArc = false, dx1 = -0.8f, dy1 = 0f)
+ arcToRelative(0.4f, 0.4f, 0f, isMoreThanHalf = true, isPositiveArc = false, dx1 = 0.8f, dy1 = 0f)
+ // Right connector (center 21.5, 12.0)
+ moveTo(21.9f, 12.0f)
+ arcToRelative(0.4f, 0.4f, 0f, isMoreThanHalf = true, isPositiveArc = false, dx1 = -0.8f, dy1 = 0f)
+ arcToRelative(0.4f, 0.4f, 0f, isMoreThanHalf = true, isPositiveArc = false, dx1 = 0.8f, dy1 = 0f)
+
+ // ── 4. CARELEVO text bars (CW rects) ─ +1 → fills inside window ───
+ // Go RIGHT first from TL (CW in screen-Y-down coords)
+ moveTo(13.2f, 10.7f)
+ lineTo(19.5f, 10.7f)
+ lineTo(19.5f, 11.2f)
+ lineTo(13.2f, 11.2f)
+ close()
+ moveTo(13.2f, 11.75f)
+ lineTo(18.3f, 11.75f)
+ lineTo(18.3f, 12.25f)
+ lineTo(13.2f, 12.25f)
+ close()
+ moveTo(13.2f, 12.8f)
+ lineTo(19.5f, 12.8f)
+ lineTo(19.5f, 13.3f)
+ lineTo(13.2f, 13.3f)
+ close()
+ }
+
+ // ── Lens arc – 300° open arc, gap on right (C보다 조금 더 길게) ──────────
+ // Center (10.1, 12.0), r = 1.75
+ // Start: 30° above right → (11.62, 11.13)
+ // End : 30° below right → (11.62, 12.88)
+ // Long CCW arc (300°) going up → left → down
+ path(
+ fill = SolidColor(Color.Transparent),
+ fillAlpha = 0f,
+ stroke = SolidColor(Color.Black),
+ strokeAlpha = 1.0f,
+ strokeLineWidth = 0.85f,
+ strokeLineCap = StrokeCap.Round,
+ strokeLineJoin = StrokeJoin.Round,
+ strokeLineMiter = 1.0f
+ ) {
+ moveTo(11.62f, 11.13f)
+ arcToRelative(1.75f, 1.75f, 0f, isMoreThanHalf = true, isPositiveArc = false, dx1 = 0f, dy1 = 1.75f)
+ }
+
+ }.build()
+}
+
+@Preview(showBackground = true, backgroundColor = 0xFFFFFFFF)
+@Composable
+private fun IcPluginCarelevoPreview() {
+ Icon(
+ imageVector = IcPluginCarelevo,
+ contentDescription = null,
+ modifier = Modifier
+ .padding(8.dp)
+ .size(48.dp),
+ tint = Color.Unspecified
+ )
+}
diff --git a/core/ui/src/main/kotlin/app/aaps/core/ui/compose/pump/WizardScreen.kt b/core/ui/src/main/kotlin/app/aaps/core/ui/compose/pump/WizardScreen.kt
index 4a1c5a55c7c2..aeba41047641 100644
--- a/core/ui/src/main/kotlin/app/aaps/core/ui/compose/pump/WizardScreen.kt
+++ b/core/ui/src/main/kotlin/app/aaps/core/ui/compose/pump/WizardScreen.kt
@@ -38,7 +38,9 @@ import app.aaps.core.ui.compose.dialogs.OkCancelDialog
* @param currentStep Current wizard step (null hides content)
* @param totalSteps Total number of steps for progress indicator
* @param currentStepIndex Zero-based current step position
- * @param canGoBack Whether back navigation is allowed on current step
+ * @param canGoBack Whether leaving the wizard is allowed on the current step. When false, the
+ * toolbar back arrow is hidden and the system back button is swallowed without showing the
+ * cancel dialog — used by steps where aborting is unsafe (e.g. mid-priming).
* @param onBack Called when user confirms exit from the wizard
* @param cancelDialogTitle Title for the cancel confirmation dialog
* @param cancelDialogText Body text for the cancel confirmation dialog
@@ -61,17 +63,21 @@ fun WizardScreen(
) {
var showCancelDialog by remember { mutableStateOf(false) }
- // Take over toolbar: back arrow shows confirmation dialog
+ // Take over toolbar: back arrow shows confirmation dialog (hidden while canGoBack is false —
+ // ViewModels compute per-step canGoBack precisely to lock the user in during irreversible
+ // steps; this parameter used to be accepted but never wired, silently disabling that gating).
if (setToolbarConfig != null) {
// Use a stable callback ref so toolbar icon can trigger dialog
val onRequestCancel = remember { { showCancelDialog = true } }
- DisposableEffect(title, onRequestCancel) {
+ DisposableEffect(title, onRequestCancel, canGoBack) {
setToolbarConfig(
ToolbarConfig(
title = title,
navigationIcon = {
- IconButton(onClick = onRequestCancel) {
- Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = null)
+ if (canGoBack) {
+ IconButton(onClick = onRequestCancel) {
+ Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = null)
+ }
}
},
actions = {}
@@ -84,9 +90,10 @@ fun WizardScreen(
}
}
- // System back button: always confirm before leaving the wizard
+ // System back button: confirm before leaving the wizard; swallow entirely on steps that
+ // must not be left.
BackHandler(enabled = true) {
- showCancelDialog = true
+ if (canGoBack) showCancelDialog = true
}
if (showCancelDialog) {
diff --git a/database/impl/src/main/kotlin/app/aaps/database/entities/UserEntry.kt b/database/impl/src/main/kotlin/app/aaps/database/entities/UserEntry.kt
index 8916473378c2..23a9712d6d38 100644
--- a/database/impl/src/main/kotlin/app/aaps/database/entities/UserEntry.kt
+++ b/database/impl/src/main/kotlin/app/aaps/database/entities/UserEntry.kt
@@ -215,6 +215,8 @@ data class UserEntry(
BgFragment,
Garmin,
Database, //for PersistenceLayer
+
+ Carelevo,
Unknown, //if necessary
;
diff --git a/database/impl/src/main/kotlin/app/aaps/database/entities/embedments/InterfaceIDs.kt b/database/impl/src/main/kotlin/app/aaps/database/entities/embedments/InterfaceIDs.kt
index 078c6cb40ca6..9ff1fca081e7 100644
--- a/database/impl/src/main/kotlin/app/aaps/database/entities/embedments/InterfaceIDs.kt
+++ b/database/impl/src/main/kotlin/app/aaps/database/entities/embedments/InterfaceIDs.kt
@@ -53,6 +53,7 @@ data class InterfaceIDs @Ignore constructor(
MEDTRUM_UNTESTED,
USER,
CACHE,
+ CARELEVO,
EQUIL;
companion object {
diff --git a/database/persistence/src/main/kotlin/app/aaps/database/persistence/converters/PumpTypeExtension.kt b/database/persistence/src/main/kotlin/app/aaps/database/persistence/converters/PumpTypeExtension.kt
index e17b554e168d..41be4641bfd4 100644
--- a/database/persistence/src/main/kotlin/app/aaps/database/persistence/converters/PumpTypeExtension.kt
+++ b/database/persistence/src/main/kotlin/app/aaps/database/persistence/converters/PumpTypeExtension.kt
@@ -42,6 +42,7 @@ fun InterfaceIDs.PumpType.fromDb(): PumpType =
InterfaceIDs.PumpType.MEDTRUM_UNTESTED -> PumpType.MEDTRUM_UNTESTED
InterfaceIDs.PumpType.CACHE -> PumpType.CACHE
InterfaceIDs.PumpType.EQUIL -> PumpType.EQUIL
+ InterfaceIDs.PumpType.CARELEVO -> PumpType.CAREMEDI_CARELEVO
}
fun PumpType.toDb(): InterfaceIDs.PumpType =
@@ -83,5 +84,6 @@ fun PumpType.toDb(): InterfaceIDs.PumpType =
PumpType.MEDTRUM_UNTESTED -> InterfaceIDs.PumpType.MEDTRUM_UNTESTED
PumpType.CACHE -> InterfaceIDs.PumpType.CACHE
PumpType.EQUIL -> InterfaceIDs.PumpType.EQUIL
+ PumpType.CAREMEDI_CARELEVO -> InterfaceIDs.PumpType.CARELEVO
}
diff --git a/database/persistence/src/main/kotlin/app/aaps/database/persistence/converters/SourcesExtension.kt b/database/persistence/src/main/kotlin/app/aaps/database/persistence/converters/SourcesExtension.kt
index c84dedfd19e7..5e544f1ec2f9 100644
--- a/database/persistence/src/main/kotlin/app/aaps/database/persistence/converters/SourcesExtension.kt
+++ b/database/persistence/src/main/kotlin/app/aaps/database/persistence/converters/SourcesExtension.kt
@@ -87,6 +87,7 @@ fun UserEntry.Sources.fromDb(): Sources =
UserEntry.Sources.Garmin -> Sources.Garmin
UserEntry.Sources.Scene -> Sources.Scene
UserEntry.Sources.Database -> Sources.Database
+ UserEntry.Sources.Carelevo -> Sources.Carelevo
UserEntry.Sources.Unknown -> Sources.Unknown
}
@@ -174,6 +175,7 @@ fun Sources.toDb(): UserEntry.Sources =
Sources.Scene -> UserEntry.Sources.Scene
Sources.Database -> UserEntry.Sources.Database
Sources.Insulin -> UserEntry.Sources.Insulin
+ Sources.Carelevo -> UserEntry.Sources.Carelevo
Sources.Unknown -> UserEntry.Sources.Unknown
}
diff --git a/implementation/src/main/kotlin/app/aaps/implementation/userEntry/UserEntryPresentationHelperImpl.kt b/implementation/src/main/kotlin/app/aaps/implementation/userEntry/UserEntryPresentationHelperImpl.kt
index faeaa91d4f94..cdeff6678232 100644
--- a/implementation/src/main/kotlin/app/aaps/implementation/userEntry/UserEntryPresentationHelperImpl.kt
+++ b/implementation/src/main/kotlin/app/aaps/implementation/userEntry/UserEntryPresentationHelperImpl.kt
@@ -47,6 +47,7 @@ import app.aaps.core.ui.compose.icons.IcNote
import app.aaps.core.ui.compose.icons.IcPatchPump
import app.aaps.core.ui.compose.icons.IcPluginAutomation
import app.aaps.core.ui.compose.icons.IcPluginAutotune
+import app.aaps.core.ui.compose.icons.IcPluginCarelevo
import app.aaps.core.ui.compose.icons.IcPluginCombo
import app.aaps.core.ui.compose.icons.IcPluginConfigBuilder
import app.aaps.core.ui.compose.icons.IcPluginDanaI
@@ -109,6 +110,7 @@ class UserEntryPresentationHelperImpl @Inject constructor(
Sources.BgFragment -> IcAaps
Sources.CalibrationDialog -> IcCalibration
Sources.CarbDialog -> IcCarbs
+ Sources.Carelevo -> IcPluginCarelevo
Sources.Combo -> IcPluginCombo
Sources.ConcentrationDialog -> IcPluginInsulin
Sources.ConfigBuilder -> IcPluginConfigBuilder
@@ -267,6 +269,7 @@ class UserEntryPresentationHelperImpl @Inject constructor(
Sources.Wear -> ElementType.AAPS.color()
Sources.WizardDialog -> ElementType.BOLUS_WIZARD.color()
Sources.Xdrip -> ElementType.CGM_XDRIP.color()
+ Sources.Carelevo -> ElementType.PUMP.color()
}
override fun listToPresentationString(list: List) =
diff --git a/pump/carelevo-emulator/build.gradle.kts b/pump/carelevo-emulator/build.gradle.kts
new file mode 100644
index 000000000000..2c8b69a9ea56
--- /dev/null
+++ b/pump/carelevo-emulator/build.gradle.kts
@@ -0,0 +1,22 @@
+plugins {
+ alias(libs.plugins.android.library)
+ alias(libs.plugins.ksp)
+ id("android-module-dependencies")
+ id("test-module-dependencies")
+ id("jacoco-module-dependencies")
+}
+
+android {
+ namespace = "app.aaps.pump.carelevo.emulator"
+}
+
+dependencies {
+ implementation(project(":core:interfaces"))
+ implementation(project(":pump:carelevo"))
+
+ testImplementation(project(":shared:tests"))
+
+ ksp(libs.com.google.dagger.compiler)
+ ksp(libs.com.google.dagger.hilt.compiler)
+ ksp(libs.com.google.dagger.android.processor)
+}
diff --git a/pump/carelevo-emulator/src/main/kotlin/app/aaps/pump/carelevo/emulator/CarelevoEmulatorBleTransport.kt b/pump/carelevo-emulator/src/main/kotlin/app/aaps/pump/carelevo/emulator/CarelevoEmulatorBleTransport.kt
new file mode 100644
index 000000000000..b30b6259f45b
--- /dev/null
+++ b/pump/carelevo-emulator/src/main/kotlin/app/aaps/pump/carelevo/emulator/CarelevoEmulatorBleTransport.kt
@@ -0,0 +1,163 @@
+package app.aaps.pump.carelevo.emulator
+
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.pump.ble.BleAdapter
+import app.aaps.core.interfaces.pump.ble.BleGatt
+import app.aaps.core.interfaces.pump.ble.BleScanner
+import app.aaps.core.interfaces.pump.ble.BleTransportListener
+import app.aaps.core.interfaces.pump.ble.PairingState
+import app.aaps.core.interfaces.pump.ble.ScannedDevice
+import app.aaps.pump.carelevo.ble.CarelevoBleTransport
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+
+/**
+ * [CarelevoBleTransport] that talks to a [CarelevoPumpEmulator] instead of real Bluetooth, so the
+ * whole CareLevo driver — sessions, pairing, commands, coordinators — runs without patch hardware.
+ *
+ * The seam is narrow: the driver never touches this directly. `BleTransportGattConnection` adapts it
+ * to a `GattConnection` and `BleClientImpl` does opcode correlation above that, so everything the
+ * protocol actually cares about still runs for real. Only the radio is fake.
+ *
+ * Each write is answered synchronously on the calling thread, which keeps tests deterministic: by the
+ * time `writeCharacteristic` returns, the notifications have already been delivered. That is safe
+ * because `BleClientImpl` registers its waiter *before* writing, so an instantaneous reply cannot race.
+ *
+ * The driver opens a fresh session per operation, so `connect`/`close` and `setListener` are exercised
+ * repeatedly; this tolerates the register → close → register cycle rather than warning about it.
+ */
+class CarelevoEmulatorBleTransport(
+ val emulator: CarelevoPumpEmulator = CarelevoPumpEmulator(),
+ private val aapsLogger: AAPSLogger? = null,
+ /** Serial reported by a discovery scan. Defaults to whatever the emulated patch already carries. */
+ private val serialNumberProvider: (() -> String)? = null
+) : CarelevoBleTransport {
+
+ private var listener: BleTransportListener? = null
+
+ @Volatile private var connected = false
+
+ val pumpState: CarelevoPumpState get() = emulator.state
+
+ /** Every frame the driver has written, in order — the assertion surface for tests. */
+ val writes: MutableList = mutableListOf()
+
+ /** Bond state of the emulated patch; flip to drive the driver's bonding paths. */
+ var bonded: Boolean = true
+ var bondCalls: Int = 0
+
+ /** `connect()` returns false, as if the BLE stack refused to start the connection. */
+ var connectRefused: Boolean = false
+
+ /** `connect()` succeeds but the patch never reports CONNECTED — drives the connect timeout. */
+ var reportConnected: Boolean = true
+
+ override var scanAddress: String? = null
+ override var onGattError133: (() -> Unit)? = null
+
+ override val adapter: BleAdapter = EmulatorAdapter()
+ override val scanner: BleScanner = EmulatorScanner()
+ override val gatt: BleGatt = EmulatorGatt()
+
+ private val _pairingState = MutableStateFlow(PairingState())
+ override val pairingState: StateFlow = _pairingState
+
+ override fun updatePairingState(state: PairingState) {
+ _pairingState.value = state
+ }
+
+ override fun setListener(listener: BleTransportListener?) {
+ this.listener = listener
+ }
+
+ // ---- BleAdapter -------------------------------------------------------------------------
+
+ private inner class EmulatorAdapter : BleAdapter {
+
+ override fun enable() {}
+ override fun getDeviceName(address: String): String = deviceName()
+ override fun isDeviceBonded(address: String): Boolean = bonded
+ override fun createBond(address: String): Boolean {
+ bondCalls++
+ bonded = true
+ return true
+ }
+
+ override fun removeBond(address: String) {
+ bonded = false
+ }
+ }
+
+ // ---- BleScanner -------------------------------------------------------------------------
+
+ private inner class EmulatorScanner : BleScanner {
+
+ private val _scannedDevices = MutableSharedFlow(replay = 1, extraBufferCapacity = 10)
+ override val scannedDevices: SharedFlow = _scannedDevices
+
+ override fun startScan() {
+ // Discovery vs reconnect is decided by isNullOrEmpty(), matching CarelevoBleTransportImpl —
+ // a null-only check would treat an empty filter as a reconnect and report a blank address.
+ val filter = scanAddress?.ifEmpty { null }
+ // A discovery scan (no address filter) is where a fresh patch gets its serial.
+ if (filter == null) serialNumberProvider?.invoke()?.let { pumpState.serialNumber = it }
+ val address = filter ?: macAddressString()
+ aapsLogger?.debug(LTag.PUMPEMULATOR, "emulator: scan reporting $address")
+ _scannedDevices.tryEmit(ScannedDevice(name = deviceName(), address = address))
+ }
+
+ override fun stopScan() {}
+ }
+
+ // ---- BleGatt ----------------------------------------------------------------------------
+
+ private inner class EmulatorGatt : BleGatt {
+
+ override fun connect(address: String): Boolean {
+ if (connectRefused) return false
+ connected = true
+ if (reportConnected) listener?.onConnectionStateChanged(true)
+ return true
+ }
+
+ override fun disconnect() {
+ if (connected) {
+ connected = false
+ listener?.onConnectionStateChanged(false)
+ }
+ }
+
+ override fun close() {
+ connected = false
+ }
+
+ override fun discoverServices() {
+ listener?.onServicesDiscovered(true)
+ }
+
+ override fun findCharacteristics(): Boolean = true
+
+ override fun enableNotifications() {
+ listener?.onDescriptorWritten()
+ }
+
+ override fun writeCharacteristic(data: ByteArray) {
+ writes += data
+ listener?.onCharacteristicWritten()
+ emulator.handle(data).forEach { listener?.onCharacteristicChanged(it) }
+ }
+ }
+
+ private fun deviceName(): String = "$DEVICE_NAME_PREFIX${pumpState.serialNumber}"
+
+ private fun macAddressString(): String =
+ pumpState.macAddress.joinToString(separator = ":") { "%02X".format(it) }
+
+ private companion object {
+
+ const val DEVICE_NAME_PREFIX = "CareLevo-"
+ }
+}
diff --git a/pump/carelevo-emulator/src/main/kotlin/app/aaps/pump/carelevo/emulator/CarelevoPumpEmulator.kt b/pump/carelevo-emulator/src/main/kotlin/app/aaps/pump/carelevo/emulator/CarelevoPumpEmulator.kt
new file mode 100644
index 000000000000..a1299443cc80
--- /dev/null
+++ b/pump/carelevo-emulator/src/main/kotlin/app/aaps/pump/carelevo/emulator/CarelevoPumpEmulator.kt
@@ -0,0 +1,544 @@
+package app.aaps.pump.carelevo.emulator
+
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import kotlin.experimental.xor
+import kotlin.math.roundToInt
+
+/**
+ * Answers CareLevo BLE commands the way a real patch does, against a live [CarelevoPumpState].
+ *
+ * The CareLevo wire has no framing, length prefix, CRC or encryption: a request is
+ * `[opcode][payload]` written verbatim, and a response is a raw notification whose byte 0 is the
+ * opcode the client correlates on. So [handle] is the whole protocol — it takes one written frame
+ * and returns the notification frames the patch would send back, in order.
+ *
+ * Returning a *list* is what makes the two irregular shapes fall out naturally: the 0x33 patch-info
+ * report is two frames (0x93 + 0x94), and the 0x12 safety check streams N progress frames before its
+ * terminal one. An empty list means the patch stays silent.
+ *
+ * Response opcodes are a hardcoded table, never computed. The rule is *mostly* `request + 0x60`
+ * (arithmetic — `or 0x60` breaks every opcode from 0x21 up), but there are real exceptions: 0x19→0x7A
+ * and 0x1A→0x79 are swapped, and 0x4B answers on 0xBB.
+ */
+class CarelevoPumpEmulator(
+ val state: CarelevoPumpState = CarelevoPumpState(),
+ private val aapsLogger: AAPSLogger? = null
+) {
+
+ /** Frames the patch sends back for [request]; empty when it stays silent. */
+ fun handle(request: ByteArray): List {
+ if (request.isEmpty()) return emptyList()
+ val opcode = request[0]
+ if (opcode in state.silentOpcodes) {
+ aapsLogger?.debug(LTag.PUMPEMULATOR, "emulator: silently dropping 0x${hex(opcode)}")
+ return emptyList()
+ }
+ val responses = dispatch(opcode, request)
+ aapsLogger?.debug(
+ LTag.PUMPEMULATOR,
+ "emulator: 0x${hex(opcode)} -> ${responses.joinToString(", ") { "0x${hex(it[0])}" }.ifEmpty { "(silence)" }}"
+ )
+ return responses
+ }
+
+ private fun dispatch(opcode: Byte, request: ByteArray): List = when (opcode) {
+ OP_SET_TIME -> setTime(request)
+ OP_SAFETY_CHECK -> safetyCheck()
+ OP_BASAL_SET -> basalProgram(request, RESP_BASAL_SET)
+ OP_BASAL_UPDATE -> basalProgram(request, RESP_BASAL_UPDATE)
+ OP_NOTICE_THRESHOLD -> noticeThreshold(request)
+ OP_INFUSION_THRESHOLD -> infusionThreshold(request)
+ OP_BUZZ_MODE -> buzzMode(request)
+ OP_NEEDLE_ACK -> needleAck(request)
+ OP_NEEDLE_STATUS -> needleStatus()
+ OP_THRESHOLD_SETUP -> thresholdSetup(request)
+ OP_ADDITIONAL_PRIMING -> additionalPriming()
+ OP_TEMP_BASAL -> tempBasal()
+ OP_IMMEDIATE_BOLUS -> immediateBolus(request)
+ OP_EXTEND_BOLUS -> extendBolus(request)
+ OP_PUMP_STOP -> pumpStop(request)
+ OP_PUMP_RESUME -> pumpResume(request)
+ OP_EXTEND_BOLUS_CANCEL -> extendBolusCancel()
+ OP_BOLUS_CANCEL -> bolusCancel()
+ OP_TEMP_BASAL_CANCEL -> tempBasalCancel()
+ OP_INFUSION_INFO -> infusionInfo(request)
+ OP_PATCH_INFO -> patchInfoFrames()
+ OP_PATCH_DISCARD -> patchDiscard()
+ OP_MAC_ADDRESS -> macAddress(request)
+ OP_ALARM_CLEAR -> alarmClear(request)
+ OP_ALERT_ALARM_SET -> alertAlarmSet(request)
+ OP_APP_AUTH -> appAuth(request)
+ else -> {
+ aapsLogger?.debug(LTag.PUMPEMULATOR, "emulator: unknown opcode 0x${hex(opcode)}")
+ emptyList()
+ }
+ }
+
+ // ---- Pairing ----------------------------------------------------------------------------
+
+ /** `[0x9B][mac 6][checksum ..]`. The key is retained so [appAuth] can verify the app's fold. */
+ private fun macAddress(request: ByteArray): List {
+ state.lastMacKey = if (request.size > 1) request.u(1) else null
+ return listOf(byteArrayOf(RESP_MAC_ADDRESS) + state.macAddress + state.macCheckSum)
+ }
+
+ /**
+ * Verifies the app's handshake rather than rubber-stamping it: the app XOR-folds
+ * `(mac || checksum)` starting from the key it sent on 0x3B, so the same fold here must match.
+ * A real patch rejects a wrong fold, and so does this — that is the point of emulating it.
+ */
+ private fun appAuth(request: ByteArray): List {
+ val key = state.lastMacKey
+ val expected = key?.let { (state.macAddress + state.macCheckSum).fold(it.toByte()) { acc, b -> acc xor b } }
+ val offered = if (request.size > 1) request[1] else null
+ val result = when {
+ state.resultCodeOverrides.containsKey(OP_APP_AUTH) -> state.resultFor(OP_APP_AUTH)
+ expected == null || offered == null -> AUTH_FAILED
+ offered != expected -> {
+ aapsLogger?.debug(
+ LTag.PUMPEMULATOR,
+ "emulator: auth rejected, expected 0x${hex(expected)} got 0x${hex(offered)}"
+ )
+ AUTH_FAILED
+ }
+
+ else -> CarelevoPumpState.RESULT_SUCCESS
+ }
+ return listOf(byteArrayOf(RESP_APP_AUTH, result.toByte()))
+ }
+
+ // ---- Time and patch info ----------------------------------------------------------------
+
+ /**
+ * 0x11 carries a byte-identical frame for two different commands; only `subId` (byte 1) tells
+ * them apart. `subId == 0` is the activation path, which waits for the patch-info pair and would
+ * hang on a 0x71; every other subId is a plain set-time that wants the 0x71 ack.
+ */
+ private fun setTime(request: ByteArray): List {
+ val subId = if (request.size > 1) request.u(1) else 0
+ val result = state.resultFor(OP_SET_TIME)
+ if (request.size >= SET_TIME_LENGTH && result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.subId = subId
+ state.runningMinutes = 0
+ }
+ return if (subId == 0) patchInfoFrames()
+ else listOf(byteArrayOf(RESP_SET_TIME, result.toByte()))
+ }
+
+ /**
+ * RPT1 `[0x93][result][serial 13 ASCII]` and RPT2 `[0x94][result][fw 4 ASCII][unused 5][model 5]`.
+ * Order is irrelevant — the client keys them by opcode — but both must arrive or the request hangs.
+ */
+ private fun patchInfoFrames(): List {
+ val result = state.resultFor(OP_PATCH_INFO).toByte()
+ val rpt1 = byteArrayOf(RESP_PATCH_INFO_RPT1, result) + state.serialNumber.ascii(SERIAL_LENGTH)
+ val rpt2 = byteArrayOf(RESP_PATCH_INFO_RPT2, result) +
+ state.firmwareVersion.ascii(FIRMWARE_LENGTH) +
+ ByteArray(RPT2_UNUSED_LENGTH) +
+ state.modelBytes.copyOf(MODEL_LENGTH)
+ return listOf(rpt1, rpt2)
+ }
+
+ // ---- Safety check -----------------------------------------------------------------------
+
+ /**
+ * Streams progress frames then a terminal one, all on 0x72. A frame is progress purely because
+ * its result byte is 4 or 18; anything else — including 0 for success — ends the stream.
+ *
+ * Frames are 6 bytes. Never emit 5: `SafetyCheckCommand.decode` reads index 5 whenever
+ * `size > 4`, so a 5-byte frame throws out of bounds instead of failing cleanly.
+ */
+ private fun safetyCheck(): List {
+ val frames = mutableListOf()
+ repeat(state.safetyCheckProgressFrames) { frames += safetyFrame(SAFETY_PROGRESS_RESULT) }
+ frames += safetyFrame(state.safetyCheckResult)
+ if (state.safetyCheckResult == CarelevoPumpState.RESULT_SUCCESS) state.pumpStateRaw = PUMP_STATE_RUNNING
+ return frames
+ }
+
+ private fun safetyFrame(result: Int): ByteArray = byteArrayOf(
+ RESP_SAFETY_CHECK,
+ result.toByte(),
+ (state.safetyCheckVolume / HUNDRED).toByte(),
+ (state.safetyCheckVolume % HUNDRED).toByte(),
+ (state.safetyCheckDurationSeconds / SECONDS_PER_MINUTE).toByte(),
+ (state.safetyCheckDurationSeconds % SECONDS_PER_MINUTE).toByte()
+ )
+
+ // ---- Basal ------------------------------------------------------------------------------
+
+ /**
+ * Each sequence is its own round-trip: the ack carries no seqNo, so the pump simply banks the
+ * segments and answers `[resp][result]`. The program only counts as set once seq 2 lands.
+ */
+ private fun basalProgram(request: ByteArray, responseOpcode: Byte): List {
+ val seqNo = if (request.size > 1) request.u(1) else 0
+ val speeds = (BASAL_SEGMENT_START until request.size step 2)
+ .filter { it + 1 < request.size }
+ .map { request.u(it) + request.u(it + 1) / CENTI }
+ val requestOpcode = request[0]
+ val result = state.resultFor(requestOpcode)
+ if (result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.basalSegmentsBySeq[seqNo] = speeds
+ if (seqNo == BASAL_FINAL_SEQ) state.basalProgramCommitted = true
+ }
+ return listOf(byteArrayOf(responseOpcode, result.toByte()))
+ }
+
+ // ---- Settings ---------------------------------------------------------------------------
+
+ /** `[0x75][type]` — byte 1 echoes the type; there is no result code, arrival means success. */
+ private fun noticeThreshold(request: ByteArray): List {
+ val type = if (request.size > 1) request.u(1) else 0
+ val value = if (request.size > 2) request.u(2) else 0
+ when (type) {
+ NOTICE_TYPE_LOW_INSULIN -> state.lowInsulinNotice = value
+ NOTICE_TYPE_EXPIRY -> state.expiryNotice = value
+ }
+ return listOf(byteArrayOf(RESP_NOTICE_THRESHOLD, type.toByte()))
+ }
+
+ /** `[0x77][type][result]` — result sits at index 2 here, because byte 1 echoes the type. */
+ private fun infusionThreshold(request: ByteArray): List {
+ val flag = if (request.size > 1) request[1] else 0
+ val result = state.resultFor(OP_INFUSION_THRESHOLD)
+ if (request.size >= 4 && result == CarelevoPumpState.RESULT_SUCCESS) {
+ val value = request.u(2) + request.u(3) / CENTI
+ if (flag == FLAG_MAX_VOLUME) state.maxBolusDose = value else state.maxBasalSpeed = value
+ }
+ return listOf(byteArrayOf(RESP_INFUSION_THRESHOLD, flag, result.toByte()))
+ }
+
+ private fun buzzMode(request: ByteArray): List {
+ val result = state.resultFor(OP_BUZZ_MODE)
+ if (request.size > 1 && result == CarelevoPumpState.RESULT_SUCCESS) state.buzzUse = request[1] == FLAG_ON
+ return listOf(byteArrayOf(RESP_BUZZ_MODE, result.toByte()))
+ }
+
+ private fun thresholdSetup(request: ByteArray): List {
+ val result = state.resultFor(OP_THRESHOLD_SETUP)
+ if (request.size >= THRESHOLD_SETUP_LENGTH && result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.insulinRemainsThreshold = request.u(1)
+ state.expiryThreshold = request.u(2)
+ state.maxBasalSpeed = request.u(3) + request.u(4) / CENTI
+ state.maxBolusDose = request.u(5) + request.u(6) / CENTI
+ state.buzzUse = request[7] == FLAG_ON
+ }
+ return listOf(byteArrayOf(RESP_THRESHOLD_SETUP, result.toByte()))
+ }
+
+ private fun alertAlarmSet(request: ByteArray): List {
+ val result = state.resultFor(OP_ALERT_ALARM_SET)
+ if (request.size > 1 && result == CarelevoPumpState.RESULT_SUCCESS) state.alertAlarmMode = request.u(1)
+ return listOf(byteArrayOf(RESP_ALERT_ALARM_SET, result.toByte()))
+ }
+
+ /** `[0xA7][subId][cause][result]` — result at index 3. */
+ private fun alarmClear(request: ByteArray): List {
+ val alarmType = if (request.size > 1) request[1] else 0
+ val cause = if (request.size > 2) request[2] else 0
+ return listOf(byteArrayOf(RESP_ALARM_CLEAR, alarmType, cause, state.resultFor(OP_ALARM_CLEAR).toByte()))
+ }
+
+ // ---- Needle and priming -----------------------------------------------------------------
+
+ /** 0x19 answers on 0x7A — swapped with [needleStatus]. Request byte 1: 0x00 success, 0x01 failure. */
+ private fun needleAck(request: ByteArray): List {
+ val result = state.resultFor(OP_NEEDLE_ACK)
+ if (request.size > 1 && request[1] == NEEDLE_FLAG_SUCCESS && result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.needleInserted = true
+ }
+ return listOf(byteArrayOf(RESP_NEEDLE_ACK, result.toByte()))
+ }
+
+ /** 0x1A answers on 0x79 — swapped with [needleAck]. */
+ private fun needleStatus(): List =
+ listOf(byteArrayOf(RESP_NEEDLE_STATUS, state.resultFor(OP_NEEDLE_STATUS).toByte()))
+
+ private fun additionalPriming(): List {
+ val result = state.resultFor(OP_ADDITIONAL_PRIMING)
+ if (result == CarelevoPumpState.RESULT_SUCCESS) state.primingCount++
+ return listOf(byteArrayOf(RESP_ADDITIONAL_PRIMING, result.toByte()))
+ }
+
+ // ---- Delivery ---------------------------------------------------------------------------
+
+ /**
+ * The ack is result-only, so the emulator does not need to distinguish the two modes — worth
+ * knowing that they are told apart by frame length alone (6 bytes BY_UNIT with a trailing 0x00,
+ * 5 bytes BY_PERCENT), since the opcode and layout are otherwise identical.
+ */
+ private fun tempBasal(): List {
+ val result = state.resultFor(OP_TEMP_BASAL)
+ if (result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.tempBasalRunning = true
+ state.modeRaw = MODE_TEMP_BASAL
+ }
+ return listOf(byteArrayOf(RESP_TEMP_BASAL, result.toByte()))
+ }
+
+ private fun tempBasalCancel(): List {
+ val result = state.resultFor(OP_TEMP_BASAL_CANCEL)
+ if (result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.tempBasalRunning = false
+ state.modeRaw = MODE_BASAL
+ }
+ return listOf(byteArrayOf(RESP_TEMP_BASAL_CANCEL, result.toByte()))
+ }
+
+ /**
+ * `[0x84][actionId][result][mm][ss][remain 3]`. Byte 1 **must** echo the request's actionId —
+ * the client correlates on it and silently discards a frame that does not match, hanging the call.
+ */
+ private fun immediateBolus(request: ByteArray): List {
+ val actionId = if (request.size > 1) request[1] else 0
+ val volume = if (request.size > 3) request.u(2) + request.u(3) / CENTI else 0.0
+ val result = state.resultFor(OP_IMMEDIATE_BOLUS)
+ if (result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.activeBolusActionId = actionId.toUByte().toInt()
+ state.modeRaw = MODE_IMME_BOLUS
+ state.insulinRemaining = (state.insulinRemaining - volume).coerceAtLeast(0.0)
+ state.infusedTotalBolus += volume
+ // The emulated bolus lands immediately rather than ramping, so the whole dose counts as
+ // infused — a later cancel must report that, not 0 U for insulin the totals already hold.
+ state.bolusInfusedAmount = volume
+ }
+ val seconds = (volume * SECONDS_PER_UNIT).roundToInt()
+ return listOf(
+ byteArrayOf(
+ RESP_IMMEDIATE_BOLUS,
+ actionId,
+ result.toByte(),
+ (seconds / SECONDS_PER_MINUTE).toByte(),
+ (seconds % SECONDS_PER_MINUTE).toByte()
+ ) + encodeHundredsUnitsCenti(state.insulinRemaining)
+ )
+ }
+
+ /** `[0x8C][result][units][centi]` — the infused amount is 2 bytes here, with no hundreds byte. */
+ private fun bolusCancel(): List {
+ val result = state.resultFor(OP_BOLUS_CANCEL)
+ val infused = state.bolusInfusedAmount
+ if (result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.activeBolusActionId = null
+ state.modeRaw = MODE_BASAL
+ }
+ return listOf(byteArrayOf(RESP_BOLUS_CANCEL, result.toByte()) + encodeUnitsCenti(infused))
+ }
+
+ /**
+ * `[0x85][result][mm][ss]`. The decoder recombines bytes 2..3 as `[2] * 60 + [3]` **seconds**, so
+ * the requested duration goes into byte 2 as whole minutes — halving it again by 60 would report
+ * a 90-minute bolus as 90 seconds.
+ *
+ * Byte 2 caps the reportable duration at 255 minutes; a longer request is clamped rather than
+ * silently wrapping, which is the protocol's limit and not something the emulator can widen.
+ */
+ private fun extendBolus(request: ByteArray): List {
+ val result = state.resultFor(OP_EXTEND_BOLUS)
+ val hour = if (request.size > 5) request.u(5) else 0
+ val min = if (request.size > 6) request.u(6) else 0
+ if (result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.extendedBolusRunning = true
+ state.extendedInfusedAmount = 0.0
+ state.modeRaw = MODE_EXTEND_BOLUS
+ }
+ val totalMinutes = (hour * MINUTES_PER_HOUR + min).coerceAtMost(MAX_REPORTABLE_MINUTES)
+ return listOf(byteArrayOf(RESP_EXTEND_BOLUS, result.toByte(), totalMinutes.toByte(), 0))
+ }
+
+ private fun extendBolusCancel(): List {
+ val result = state.resultFor(OP_EXTEND_BOLUS_CANCEL)
+ val infused = state.extendedInfusedAmount
+ if (result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.extendedBolusRunning = false
+ state.modeRaw = MODE_BASAL
+ }
+ return listOf(byteArrayOf(RESP_EXTEND_BOLUS_CANCEL, result.toByte()) + encodeUnitsCenti(infused))
+ }
+
+ // ---- Stop / resume / discard ------------------------------------------------------------
+
+ private fun pumpStop(request: ByteArray): List {
+ val result = state.resultFor(OP_PUMP_STOP)
+ if (result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.stopped = true
+ if (request.size > 3) state.subId = request.u(3)
+ }
+ return listOf(byteArrayOf(RESP_PUMP_STOP, result.toByte()))
+ }
+
+ /** `[0x87][result][mode]` — the optional 4th subId byte is left off; the decoder defaults it to 0. */
+ private fun pumpResume(request: ByteArray): List {
+ val mode = if (request.size > 1) request[1] else 0
+ val result = state.resultFor(OP_PUMP_RESUME)
+ if (result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.stopped = false
+ state.modeRaw = MODE_BASAL
+ }
+ return listOf(byteArrayOf(RESP_PUMP_RESUME, result.toByte(), mode))
+ }
+
+ private fun patchDiscard(): List {
+ val result = state.resultFor(OP_PATCH_DISCARD)
+ if (result == CarelevoPumpState.RESULT_SUCCESS) {
+ state.discarded = true
+ state.pumpStateRaw = PUMP_STATE_READY
+ }
+ return listOf(byteArrayOf(RESP_PATCH_DISCARD, result.toByte()))
+ }
+
+ // ---- Status -----------------------------------------------------------------------------
+
+ /**
+ * The 20-byte status frame. Bytes 13..14 are documented but never decoded — they still have to be
+ * present, because the decoder reads index 19 and requires the full length.
+ */
+ private fun infusionInfo(request: ByteArray): List {
+ val inquiryType = if (request.size > 1) request.u(1) else 0
+ val frame = ByteArray(INFUSION_INFO_LENGTH)
+ frame[0] = RESP_INFUSION_INFO
+ frame[1] = inquiryType.toByte()
+ frame[2] = (state.runningMinutes / MINUTES_PER_HOUR).toByte()
+ frame[3] = (state.runningMinutes % MINUTES_PER_HOUR).toByte()
+ encodeHundredsUnitsCenti(state.insulinRemaining).copyInto(frame, 4)
+ encodeUnitsCenti(state.infusedTotalBasal).copyInto(frame, 7)
+ encodeUnitsCenti(state.infusedTotalBolus).copyInto(frame, 9)
+ frame[11] = state.pumpStateRaw.toByte()
+ frame[12] = state.modeRaw.toByte()
+ // 13..14 (infuseSetMinutes) intentionally left zero — present but never read.
+ encodeUnitsCenti(state.infusedTotalBolus).copyInto(frame, 15)
+ frame[17] = (state.runningMinutes / MINUTES_PER_HOUR).toByte()
+ frame[18] = (state.runningMinutes % MINUTES_PER_HOUR).toByte()
+ frame[19] = 0
+ return listOf(frame)
+ }
+
+ // ---- Encoding helpers -------------------------------------------------------------------
+
+ /** `[hundreds, units, centi]` — the 3-byte reservoir encoding of 0x91[4..6] and 0x84[5..7]. */
+ private fun encodeHundredsUnitsCenti(value: Double): ByteArray {
+ val centiTotal = (value * HUNDRED).roundToInt().coerceAtLeast(0)
+ return byteArrayOf(
+ (centiTotal / TEN_THOUSAND).toByte(),
+ ((centiTotal / HUNDRED) % HUNDRED).toByte(),
+ (centiTotal % HUNDRED).toByte()
+ )
+ }
+
+ /** `[units, centi]` — the 2-byte amount encoding of the 0x91 totals and the 0x89/0x8C acks. */
+ private fun encodeUnitsCenti(value: Double): ByteArray {
+ val centiTotal = (value * HUNDRED).roundToInt().coerceAtLeast(0)
+ return byteArrayOf((centiTotal / HUNDRED).toByte(), (centiTotal % HUNDRED).toByte())
+ }
+
+ /** Fixed-width ASCII, space-padded or truncated — the frame layout is positional. */
+ private fun String.ascii(length: Int): ByteArray =
+ padEnd(length).take(length).toByteArray(Charsets.US_ASCII)
+
+ private fun ByteArray.u(index: Int): Int = this[index].toUByte().toInt()
+
+ private fun hex(value: Byte): String = "%02X".format(value)
+
+ @Suppress("unused")
+ companion object {
+
+ // Requests
+ const val OP_SET_TIME: Byte = 0x11
+ const val OP_SAFETY_CHECK: Byte = 0x12
+ const val OP_BASAL_SET: Byte = 0x13
+ const val OP_NOTICE_THRESHOLD: Byte = 0x15
+ const val OP_INFUSION_THRESHOLD: Byte = 0x17
+ const val OP_BUZZ_MODE: Byte = 0x18
+ const val OP_NEEDLE_ACK: Byte = 0x19
+ const val OP_NEEDLE_STATUS: Byte = 0x1A
+ const val OP_THRESHOLD_SETUP: Byte = 0x1B
+ const val OP_ADDITIONAL_PRIMING: Byte = 0x1D
+ const val OP_BASAL_UPDATE: Byte = 0x21
+ const val OP_TEMP_BASAL: Byte = 0x23
+ const val OP_IMMEDIATE_BOLUS: Byte = 0x24
+ const val OP_EXTEND_BOLUS: Byte = 0x25
+ const val OP_PUMP_STOP: Byte = 0x26
+ const val OP_PUMP_RESUME: Byte = 0x27
+ const val OP_EXTEND_BOLUS_CANCEL: Byte = 0x29
+ const val OP_BOLUS_CANCEL: Byte = 0x2C
+ const val OP_TEMP_BASAL_CANCEL: Byte = 0x2D
+ const val OP_INFUSION_INFO: Byte = 0x31
+ const val OP_PATCH_INFO: Byte = 0x33
+ const val OP_PATCH_DISCARD: Byte = 0x36
+ const val OP_MAC_ADDRESS: Byte = 0x3B
+ const val OP_ALARM_CLEAR: Byte = 0x47
+ const val OP_ALERT_ALARM_SET: Byte = 0x48
+ const val OP_APP_AUTH: Byte = 0x4B
+
+ // Responses — hardcoded, never computed from the request.
+ const val RESP_SET_TIME: Byte = 0x71
+ const val RESP_SAFETY_CHECK: Byte = 0x72
+ const val RESP_BASAL_SET: Byte = 0x73
+ const val RESP_NOTICE_THRESHOLD: Byte = 0x75
+ const val RESP_INFUSION_THRESHOLD: Byte = 0x77
+ const val RESP_BUZZ_MODE: Byte = 0x78
+ const val RESP_NEEDLE_STATUS: Byte = 0x79 // 0x1A -> 0x79, swapped with the ack below
+ const val RESP_NEEDLE_ACK: Byte = 0x7A // 0x19 -> 0x7A
+ const val RESP_THRESHOLD_SETUP: Byte = 0x7B
+ const val RESP_ADDITIONAL_PRIMING: Byte = 0x7D
+ val RESP_BASAL_UPDATE: Byte = 0x81.toByte()
+ val RESP_TEMP_BASAL: Byte = 0x83.toByte()
+ val RESP_IMMEDIATE_BOLUS: Byte = 0x84.toByte()
+ val RESP_EXTEND_BOLUS: Byte = 0x85.toByte()
+ val RESP_PUMP_STOP: Byte = 0x86.toByte()
+ val RESP_PUMP_RESUME: Byte = 0x87.toByte()
+ val RESP_EXTEND_BOLUS_CANCEL: Byte = 0x89.toByte()
+ val RESP_BOLUS_CANCEL: Byte = 0x8C.toByte()
+ val RESP_TEMP_BASAL_CANCEL: Byte = 0x8D.toByte()
+ val RESP_INFUSION_INFO: Byte = 0x91.toByte()
+ val RESP_PATCH_INFO_RPT1: Byte = 0x93.toByte()
+ val RESP_PATCH_INFO_RPT2: Byte = 0x94.toByte()
+ val RESP_PATCH_DISCARD: Byte = 0x96.toByte()
+ val RESP_MAC_ADDRESS: Byte = 0x9B.toByte()
+ val RESP_ALARM_CLEAR: Byte = 0xA7.toByte()
+ val RESP_ALERT_ALARM_SET: Byte = 0xA8.toByte()
+ val RESP_APP_AUTH: Byte = 0xBB.toByte() // 0x4B -> 0xBB, not 0xAB and not 0xBA
+
+ /** Result byte of a 0x72 frame that means "still working" — see `SafetyCheckCommand`. */
+ const val SAFETY_PROGRESS_RESULT = 4
+ const val AUTH_FAILED = 1
+
+ const val PUMP_STATE_READY = 0
+ const val PUMP_STATE_RUNNING = 2
+
+ const val MODE_BASAL = 1
+ const val MODE_TEMP_BASAL = 2
+ const val MODE_IMME_BOLUS = 3
+ const val MODE_EXTEND_BOLUS = 5
+
+ const val FLAG_ON: Byte = 0x01
+ const val FLAG_MAX_VOLUME: Byte = 0x01
+ const val NEEDLE_FLAG_SUCCESS: Byte = 0x00
+ const val NOTICE_TYPE_LOW_INSULIN = 0
+ const val NOTICE_TYPE_EXPIRY = 1
+
+ const val SET_TIME_LENGTH = 11
+ const val THRESHOLD_SETUP_LENGTH = 8
+ const val INFUSION_INFO_LENGTH = 20
+ const val SERIAL_LENGTH = 13
+ const val FIRMWARE_LENGTH = 4
+ const val MODEL_LENGTH = 5
+ const val RPT2_UNUSED_LENGTH = 5
+ const val BASAL_SEGMENT_START = 2
+ const val BASAL_FINAL_SEQ = 2
+
+ const val HUNDRED = 100
+ const val TEN_THOUSAND = 10_000
+ const val CENTI = 100.0
+ const val SECONDS_PER_MINUTE = 60
+ const val MINUTES_PER_HOUR = 60
+
+ /** Rough delivery rate used to fabricate the 0x84 expected-duration bytes. */
+ const val SECONDS_PER_UNIT = 20
+
+ /** Byte 2 of the 0x85 ack carries whole minutes, so the wire cannot report beyond this. */
+ const val MAX_REPORTABLE_MINUTES = 255
+ }
+}
diff --git a/pump/carelevo-emulator/src/main/kotlin/app/aaps/pump/carelevo/emulator/CarelevoPumpState.kt b/pump/carelevo-emulator/src/main/kotlin/app/aaps/pump/carelevo/emulator/CarelevoPumpState.kt
new file mode 100644
index 000000000000..6fb84af37232
--- /dev/null
+++ b/pump/carelevo-emulator/src/main/kotlin/app/aaps/pump/carelevo/emulator/CarelevoPumpState.kt
@@ -0,0 +1,123 @@
+package app.aaps.pump.carelevo.emulator
+
+/**
+ * Mutable state of the emulated CareLevo patch.
+ *
+ * The emulator answers status queries from here rather than from canned frames, so the driver sees a
+ * patch that remembers what it was told: a basal program written over three sequences, a bolus that
+ * draws the reservoir down, a stop that reports itself as stopped.
+ *
+ * Raw codes mirror `CarelevoBtEnums` and are deliberately raw (not enums) because they go on the wire:
+ * - [pumpStateRaw]: 0 READY, 1 PRIMING, 2 RUNNING — anything else decodes to ERROR
+ * - [modeRaw]: 1 BASAL, 2 TEMP_BASAL, 3 IMME_BOLUS, 4 EXTEND_IMME_BOLUS, 5 EXTEND_BOLUS.
+ * **0 decodes to ERROR**, so it is never a resting value.
+ */
+class CarelevoPumpState {
+
+ // ---- Identity ---------------------------------------------------------------------------
+
+ /** Exactly 13 chars — occupies bytes 2..14 of the 0x93 report, one ASCII byte per char. */
+ var serialNumber: String = "CL24000000001"
+
+ /** Exactly 4 chars — bytes 2..5 of the 0x94 report, ASCII. */
+ var firmwareVersion: String = "1.10"
+
+ /**
+ * Five raw bytes at 0x94[11..15]. The decoder concatenates each byte's DECIMAL value, so
+ * `[1, 2, 0, 0, 0]` reads back as the model name "12000" — it is not ASCII.
+ */
+ var modelBytes: ByteArray = byteArrayOf(1, 2, 0, 0, 0)
+
+ /** Six raw bytes, MSB first; surfaces to the driver as the uppercase hex "94B2161D2F6D". */
+ var macAddress: ByteArray = byteArrayOf(0x94.toByte(), 0xB2.toByte(), 0x16, 0x1D, 0x2F, 0x6D)
+
+ /** Trailing checksum bytes of the 0x9B frame. Content is arbitrary — see [lastMacKey]. */
+ var macCheckSum: ByteArray = byteArrayOf(0x5A)
+
+ /** Key from the last 0x3B request, retained so 0x4B can verify the app's XOR fold. */
+ var lastMacKey: Int? = null
+
+ // ---- Reservoir and totals ---------------------------------------------------------------
+
+ /** Units remaining. Reported by 0x91 and by the 0x84 bolus ack. */
+ var insulinRemaining: Double = 200.0
+ var infusedTotalBasal: Double = 0.0
+ var infusedTotalBolus: Double = 0.0
+
+ // ---- Lifecycle --------------------------------------------------------------------------
+
+ var pumpStateRaw: Int = 2
+ var modeRaw: Int = 1
+ var subId: Int = 0
+ var runningMinutes: Int = 0
+ var stopped: Boolean = false
+ var discarded: Boolean = false
+ var needleInserted: Boolean = false
+ var primingCount: Int = 0
+
+ // ---- Basal ------------------------------------------------------------------------------
+
+ /**
+ * Segment speeds accumulated per sequence number. A full program is three independent writes
+ * (seq 0, 1, 2), each separately acked; [basalProgramCommitted] flips only once seq 2 lands.
+ */
+ val basalSegmentsBySeq: MutableMap> = mutableMapOf()
+ var basalProgramCommitted: Boolean = false
+
+ /** Set of the whole program, in segment order, once all three sequences have arrived. */
+ val basalProgram: List
+ get() = (0..2).flatMap { basalSegmentsBySeq[it].orEmpty() }
+
+ // ---- Temp basal / bolus -----------------------------------------------------------------
+
+ var tempBasalRunning: Boolean = false
+ var extendedBolusRunning: Boolean = false
+
+ /** actionId of the in-flight immediate bolus; echoed back on 0x84 for correlation. */
+ var activeBolusActionId: Int? = null
+
+ /** Units already delivered by the in-flight bolus — reported by the 0x8C cancel ack. */
+ var bolusInfusedAmount: Double = 0.0
+ var extendedInfusedAmount: Double = 0.0
+
+ // ---- Thresholds and settings ------------------------------------------------------------
+
+ var insulinRemainsThreshold: Int = 20
+ var expiryThreshold: Int = 72
+ var maxBasalSpeed: Double = 15.0
+ var maxBolusDose: Double = 25.0
+ var buzzUse: Boolean = false
+ var lowInsulinNotice: Int = 20
+ var expiryNotice: Int = 72
+ var alertAlarmMode: Int = 0
+
+ // ---- Safety check -----------------------------------------------------------------------
+
+ /** Progress frames the 0x12 stream emits before its terminal frame. */
+ var safetyCheckProgressFrames: Int = 2
+
+ /** Priming volume reported by the safety-check stream, in whole units. */
+ var safetyCheckVolume: Int = 210
+
+ /** Priming duration reported by the safety-check stream, in seconds. */
+ var safetyCheckDurationSeconds: Int = 210
+
+ /** Terminal result of the safety-check stream. 0 = success; see `SafetyCheckCommand`. */
+ var safetyCheckResult: Int = 0
+
+ // ---- Fault injection --------------------------------------------------------------------
+
+ /** Opcodes the patch silently ignores, so a caller's timeout is the only way out. */
+ val silentOpcodes: MutableSet = mutableSetOf()
+
+ /** Per-opcode result-code override, for driving the driver's error paths. */
+ val resultCodeOverrides: MutableMap = mutableMapOf()
+
+ /** Result code this opcode should answer with — 0 (success) unless overridden. */
+ fun resultFor(requestOpcode: Byte): Int = resultCodeOverrides[requestOpcode] ?: RESULT_SUCCESS
+
+ companion object {
+
+ const val RESULT_SUCCESS = 0
+ }
+}
diff --git a/pump/carelevo-emulator/src/test/kotlin/app/aaps/pump/carelevo/emulator/CarelevoEmulatorTransportTest.kt b/pump/carelevo-emulator/src/test/kotlin/app/aaps/pump/carelevo/emulator/CarelevoEmulatorTransportTest.kt
new file mode 100644
index 000000000000..ff54c8b90e22
--- /dev/null
+++ b/pump/carelevo-emulator/src/test/kotlin/app/aaps/pump/carelevo/emulator/CarelevoEmulatorTransportTest.kt
@@ -0,0 +1,370 @@
+package app.aaps.pump.carelevo.emulator
+
+import app.aaps.core.interfaces.pump.ble.BleTransportListener
+import app.aaps.core.interfaces.pump.ble.PairingState
+import app.aaps.core.interfaces.pump.ble.PairingStep
+import app.aaps.pump.carelevo.ble.commands.InfusionInfoCommand
+import app.aaps.pump.carelevo.ble.commands.PatchDiscardCommand
+import app.aaps.pump.carelevo.ble.commands.PatchInfoCommand
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+/**
+ * Transport tests for [CarelevoEmulatorBleTransport] — the seam between the driver's `BleTransport`
+ * contract and [CarelevoPumpEmulator].
+ *
+ * Scope is deliberately the *transport*, not the protocol: [CarelevoPumpEmulatorTest] already proves
+ * every opcode round-trips through the production codec, so nothing here re-asserts frame contents
+ * beyond the response opcode needed to tell one notification from the next. What this suite pins down
+ * is the wiring the emulator adds on top:
+ * - which listener callback each `gatt` call fans out to, and **in what order** — `onCharacteristicWritten`
+ * must precede the `onCharacteristicChanged` frames, because [app.aaps.core.interfaces.pump.ble.BleGatt]
+ * answers writes synchronously and a client that saw the reply before the ack would be reading a
+ * reply to a write it does not yet believe it made;
+ * - the fault-injection switches (`connectRefused`, `reportConnected`, `silentOpcodes`) that exist
+ * purely to drive the driver's failure paths;
+ * - the register → close → register cycle the driver performs once per operation.
+ *
+ * Pure JVM: the transport takes a nullable logger and touches no Android API, so no Robolectric.
+ */
+class CarelevoEmulatorTransportTest {
+
+ private lateinit var state: CarelevoPumpState
+ private lateinit var emulator: CarelevoPumpEmulator
+ private lateinit var transport: CarelevoEmulatorBleTransport
+ private lateinit var listener: RecordingListener
+
+ @BeforeEach
+ fun setUp() {
+ state = CarelevoPumpState()
+ emulator = CarelevoPumpEmulator(state)
+ transport = CarelevoEmulatorBleTransport(emulator)
+ listener = RecordingListener()
+ transport.setListener(listener)
+ }
+
+ // ---- Listener fan-out --------------------------------------------------------------------
+
+ @Test
+ fun `the connect handshake fans out to each listener callback in order`() {
+ transport.gatt.connect(ADDRESS)
+ transport.gatt.discoverServices()
+ val found = transport.gatt.findCharacteristics()
+ transport.gatt.enableNotifications()
+
+ // The driver's session drives exactly this sequence; each step must land on its own callback.
+ assertThat(listener.events).containsExactly(CONNECTED, SERVICES_OK, DESCRIPTOR).inOrder()
+ // findCharacteristics is synchronous — it answers by return value, not by a callback.
+ assertThat(found).isTrue()
+ }
+
+ @Test
+ fun `a write acks before it delivers the notification`() {
+ transport.gatt.connect(ADDRESS)
+ listener.clear()
+
+ transport.gatt.writeCharacteristic(PatchDiscardCommand().encode())
+
+ // Order is the point: the ack must come first, or a client would see a reply to a write it
+ // does not yet believe completed.
+ assertThat(listener.events).containsExactly(WRITTEN, CHANGED).inOrder()
+ assertThat(listener.notifications.single()[0]).isEqualTo(PatchDiscardCommand.RESPONSE_OPCODE)
+ }
+
+ @Test
+ fun `a multi-frame command delivers one notification per emulator frame in order`() {
+ transport.gatt.connect(ADDRESS)
+ listener.clear()
+
+ transport.gatt.writeCharacteristic(PatchInfoCommand().encode())
+
+ // 0x33 is answered by two report frames; both must arrive as separate notifications, in order,
+ // or the client's multi-frame correlation never completes.
+ assertThat(listener.events).containsExactly(WRITTEN, CHANGED, CHANGED).inOrder()
+ assertThat(listener.notifications.map { it[0] })
+ .containsExactly(PatchInfoCommand.RPT1_OPCODE, PatchInfoCommand.RPT2_OPCODE)
+ .inOrder()
+ }
+
+ @Test
+ fun `a silent opcode still acks the write but delivers no notification`() {
+ state.silentOpcodes += InfusionInfoCommand.REQUEST_OPCODE
+ transport.gatt.connect(ADDRESS)
+ listener.clear()
+
+ transport.gatt.writeCharacteristic(InfusionInfoCommand().encode())
+
+ // The write itself still completes at the GATT layer — only the patch goes quiet, which is
+ // what leaves the caller waiting on its timeout.
+ assertThat(listener.events).containsExactly(WRITTEN)
+ assertThat(listener.notifications).isEmpty()
+ // ...and the frame is still recorded, so a test can assert what was sent into the silence.
+ assertThat(transport.writes).hasSize(1)
+ }
+
+ @Test
+ fun `writes records every frame in order`() {
+ val patchInfo = PatchInfoCommand().encode()
+ val infusionInfo = InfusionInfoCommand().encode()
+ val discard = PatchDiscardCommand().encode()
+
+ transport.gatt.connect(ADDRESS)
+ transport.gatt.writeCharacteristic(patchInfo)
+ transport.gatt.writeCharacteristic(infusionInfo)
+ transport.gatt.writeCharacteristic(discard)
+
+ assertThat(transport.writes.map { it.toList() })
+ .containsExactly(patchInfo.toList(), infusionInfo.toList(), discard.toList())
+ .inOrder()
+ }
+
+ // ---- Connect / disconnect ----------------------------------------------------------------
+
+ @Test
+ fun `connect refused returns false and fires no connection callback`() {
+ transport.connectRefused = true
+
+ assertThat(transport.gatt.connect(ADDRESS)).isFalse()
+
+ // The BLE stack refused to even start — the driver must not be told it connected.
+ assertThat(listener.events).isEmpty()
+ }
+
+ @Test
+ fun `connect without a connected report returns true but fires no callback`() {
+ transport.reportConnected = false
+
+ // The stack accepted the request; the patch simply never answers — this is the connect-timeout
+ // path, and it is the absence of the callback that drives it.
+ assertThat(transport.gatt.connect(ADDRESS)).isTrue()
+ assertThat(listener.events).isEmpty()
+ }
+
+ @Test
+ fun `disconnect before connect fires nothing`() {
+ transport.gatt.disconnect()
+
+ assertThat(listener.events).isEmpty()
+ }
+
+ @Test
+ fun `disconnect fires a single disconnected callback and is idempotent`() {
+ transport.gatt.connect(ADDRESS)
+ listener.clear()
+
+ transport.gatt.disconnect()
+ transport.gatt.disconnect()
+
+ // A second disconnect must stay silent — a duplicate lost-connection event would tear the
+ // session down twice.
+ assertThat(listener.connectionStates).containsExactly(false)
+ }
+
+ // ---- Bonding -----------------------------------------------------------------------------
+
+ @Test
+ fun `adapter reports the emulated bond state`() {
+ assertThat(transport.adapter.isDeviceBonded(ADDRESS)).isTrue()
+
+ transport.bonded = false
+
+ assertThat(transport.adapter.isDeviceBonded(ADDRESS)).isFalse()
+ }
+
+ @Test
+ fun `createBond counts the call and bonds the patch`() {
+ transport.bonded = false
+
+ assertThat(transport.adapter.createBond(ADDRESS)).isTrue()
+
+ assertThat(transport.bonded).isTrue()
+ assertThat(transport.adapter.isDeviceBonded(ADDRESS)).isTrue()
+ assertThat(transport.bondCalls).isEqualTo(1)
+
+ transport.adapter.createBond(ADDRESS)
+
+ assertThat(transport.bondCalls).isEqualTo(2)
+ }
+
+ @Test
+ fun `removeBond unbonds the patch`() {
+ transport.bonded = true
+
+ transport.adapter.removeBond(ADDRESS)
+
+ assertThat(transport.bonded).isFalse()
+ assertThat(transport.adapter.isDeviceBonded(ADDRESS)).isFalse()
+ }
+
+ // ---- Scanner -----------------------------------------------------------------------------
+
+ @Test
+ fun `a discovery scan asks the serial provider and reports the patch mac`() {
+ val discovering = CarelevoEmulatorBleTransport(emulator, serialNumberProvider = { PROVIDED_SERIAL })
+
+ discovering.scanner.startScan()
+ val device = runBlocking { discovering.scanner.scannedDevices.first() }
+
+ // No address filter means the pairing wizard is hunting for a fresh patch — that is where the
+ // serial comes from, so the provider decides what the patch now calls itself.
+ assertThat(discovering.pumpState.serialNumber).isEqualTo(PROVIDED_SERIAL)
+ assertThat(device.address).isEqualTo(DEFAULT_MAC)
+ assertThat(device.name).isEqualTo("CareLevo-$PROVIDED_SERIAL")
+ }
+
+ @Test
+ fun `a filtered scan reports the scan address and leaves the serial alone`() {
+ var providerCalls = 0
+ val reconnecting = CarelevoEmulatorBleTransport(
+ emulator,
+ serialNumberProvider = {
+ providerCalls++
+ PROVIDED_SERIAL
+ }
+ )
+ reconnecting.scanAddress = FILTER_ADDRESS
+
+ reconnecting.scanner.startScan()
+ val device = runBlocking { reconnecting.scanner.scannedDevices.first() }
+
+ // A filtered scan is a reconnect to a patch already known — re-deriving its serial would
+ // overwrite the identity the driver is reconnecting to.
+ assertThat(providerCalls).isEqualTo(0)
+ assertThat(reconnecting.pumpState.serialNumber).isEqualTo(DEFAULT_SERIAL)
+ assertThat(device.address).isEqualTo(FILTER_ADDRESS)
+ }
+
+ // ---- Adapter identity --------------------------------------------------------------------
+
+ @Test
+ fun `getDeviceName follows the patch serial`() {
+ assertThat(transport.adapter.getDeviceName(ADDRESS)).isEqualTo("CareLevo-$DEFAULT_SERIAL")
+
+ state.serialNumber = PROVIDED_SERIAL
+
+ // The name is derived, not cached — a re-serialled patch renames itself.
+ assertThat(transport.adapter.getDeviceName(ADDRESS)).isEqualTo("CareLevo-$PROVIDED_SERIAL")
+ }
+
+ // ---- Listener lifecycle ------------------------------------------------------------------
+
+ @Test
+ fun `setListener null detaches and a later write delivers nothing without throwing`() {
+ transport.gatt.connect(ADDRESS)
+ listener.clear()
+
+ transport.setListener(null)
+ transport.gatt.writeCharacteristic(PatchInfoCommand().encode())
+
+ assertThat(listener.events).isEmpty()
+ // The frame still reached the emulator — only the delivery path is detached.
+ assertThat(transport.writes).hasSize(1)
+ }
+
+ @Test
+ fun `re-registering a listener routes callbacks to the new listener only`() {
+ val firstSession = RecordingListener()
+ val secondSession = RecordingListener()
+
+ transport.setListener(firstSession)
+ transport.gatt.connect(ADDRESS)
+ transport.gatt.close()
+ firstSession.clear()
+
+ transport.setListener(secondSession)
+ transport.gatt.connect(ADDRESS)
+ transport.gatt.writeCharacteristic(PatchInfoCommand().encode())
+
+ // The driver opens a session per operation, so this cycle is the norm, not an edge case: a
+ // frame leaking to the closed session's listener would resolve a waiter that is already gone.
+ assertThat(secondSession.connectionStates).containsExactly(true)
+ assertThat(secondSession.notifications.map { it[0] })
+ .containsExactly(PatchInfoCommand.RPT1_OPCODE, PatchInfoCommand.RPT2_OPCODE)
+ .inOrder()
+ assertThat(firstSession.events).isEmpty()
+ }
+
+ // ---- Pairing state -----------------------------------------------------------------------
+
+ @Test
+ fun `pairing state round-trips through updatePairingState`() {
+ assertThat(transport.pairingState.value).isEqualTo(PairingState())
+ assertThat(transport.pairingState.value.step).isEqualTo(PairingStep.IDLE)
+
+ val pairing = PairingState(step = PairingStep.WAITING_FOR_PAIRING_CONFIRM, errorMessage = "confirm on patch")
+ transport.updatePairingState(pairing)
+
+ assertThat(transport.pairingState.value).isEqualTo(pairing)
+ }
+
+ // ---- State delegation --------------------------------------------------------------------
+
+ @Test
+ fun `pumpState is the emulator state instance`() {
+ // Not a copy: a test mutates `transport.pumpState` and the emulator must answer from it.
+ assertThat(transport.pumpState).isSameInstanceAs(emulator.state)
+ assertThat(transport.pumpState).isSameInstanceAs(state)
+ }
+
+ // ---- Helpers -----------------------------------------------------------------------------
+
+ /** Records every callback as a flat, ordered event log — the assertion surface for fan-out order. */
+ private class RecordingListener : BleTransportListener {
+
+ val events: MutableList = mutableListOf()
+ val connectionStates: MutableList = mutableListOf()
+ val notifications: MutableList = mutableListOf()
+
+ override fun onConnectionStateChanged(connected: Boolean) {
+ connectionStates += connected
+ events += if (connected) CONNECTED else DISCONNECTED
+ }
+
+ override fun onServicesDiscovered(success: Boolean) {
+ events += if (success) SERVICES_OK else SERVICES_FAILED
+ }
+
+ override fun onDescriptorWritten() {
+ events += DESCRIPTOR
+ }
+
+ override fun onCharacteristicChanged(data: ByteArray) {
+ notifications += data.copyOf()
+ events += CHANGED
+ }
+
+ override fun onCharacteristicWritten() {
+ events += WRITTEN
+ }
+
+ fun clear() {
+ events.clear()
+ connectionStates.clear()
+ notifications.clear()
+ }
+ }
+
+ private companion object {
+
+ /** [CarelevoPumpState.macAddress] rendered the way the scanner reports it. */
+ const val DEFAULT_MAC = "94:B2:16:1D:2F:6D"
+
+ /** The address the driver hands to `gatt`/`adapter` calls — the emulator ignores it. */
+ const val ADDRESS = DEFAULT_MAC
+ const val FILTER_ADDRESS = "AA:BB:CC:DD:EE:FF"
+
+ const val DEFAULT_SERIAL = "CL24000000001"
+ const val PROVIDED_SERIAL = "CL24000000042"
+
+ const val CONNECTED = "connected"
+ const val DISCONNECTED = "disconnected"
+ const val SERVICES_OK = "services:true"
+ const val SERVICES_FAILED = "services:false"
+ const val DESCRIPTOR = "descriptor"
+ const val WRITTEN = "written"
+ const val CHANGED = "changed"
+ }
+}
diff --git a/pump/carelevo-emulator/src/test/kotlin/app/aaps/pump/carelevo/emulator/CarelevoPumpEmulatorTest.kt b/pump/carelevo-emulator/src/test/kotlin/app/aaps/pump/carelevo/emulator/CarelevoPumpEmulatorTest.kt
new file mode 100644
index 000000000000..71ad03d61b83
--- /dev/null
+++ b/pump/carelevo-emulator/src/test/kotlin/app/aaps/pump/carelevo/emulator/CarelevoPumpEmulatorTest.kt
@@ -0,0 +1,829 @@
+package app.aaps.pump.carelevo.emulator
+
+import app.aaps.pump.carelevo.ble.commands.AdditionalPrimingCommand
+import app.aaps.pump.carelevo.ble.commands.AlarmClearCommand
+import app.aaps.pump.carelevo.ble.commands.AlertAlarmSetCommand
+import app.aaps.pump.carelevo.ble.commands.AppAuthCommand
+import app.aaps.pump.carelevo.ble.commands.BasalProgramCommand
+import app.aaps.pump.carelevo.ble.commands.BolusCancelCommand
+import app.aaps.pump.carelevo.ble.commands.BuzzModeCommand
+import app.aaps.pump.carelevo.ble.commands.ExtendBolusCancelCommand
+import app.aaps.pump.carelevo.ble.commands.ExtendBolusCommand
+import app.aaps.pump.carelevo.ble.commands.ImmediateBolusCommand
+import app.aaps.pump.carelevo.ble.commands.InfusionInfoCommand
+import app.aaps.pump.carelevo.ble.commands.InfusionThresholdCommand
+import app.aaps.pump.carelevo.ble.commands.MacAddressCommand
+import app.aaps.pump.carelevo.ble.commands.MacAddressResponse
+import app.aaps.pump.carelevo.ble.commands.NeedleAckCommand
+import app.aaps.pump.carelevo.ble.commands.NeedleStatusCommand
+import app.aaps.pump.carelevo.ble.commands.NoticeThresholdCommand
+import app.aaps.pump.carelevo.ble.commands.PatchDiscardCommand
+import app.aaps.pump.carelevo.ble.commands.PatchInfoCommand
+import app.aaps.pump.carelevo.ble.commands.PumpResumeCommand
+import app.aaps.pump.carelevo.ble.commands.PumpStopCommand
+import app.aaps.pump.carelevo.ble.commands.SafetyCheckCommand
+import app.aaps.pump.carelevo.ble.commands.SetTimeCommand
+import app.aaps.pump.carelevo.ble.commands.SetTimeForPatchInfoCommand
+import app.aaps.pump.carelevo.ble.commands.TempBasalCancelCommand
+import app.aaps.pump.carelevo.ble.commands.TempBasalCommand
+import app.aaps.pump.carelevo.ble.commands.ThresholdSetupCommand
+import com.google.common.truth.Truth.assertThat
+import org.joda.time.DateTime
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import kotlin.experimental.xor
+
+/**
+ * Wire-compatibility tests for [CarelevoPumpEmulator], driven end-to-end through the **production**
+ * codec: every request is built with the real command's `encode()` and every response is parsed with
+ * the real command's `decode(...)`. Nothing here hand-asserts an invented byte array, so a passing
+ * test means the emulator is byte-for-byte compatible with what `BleClientImpl` actually writes and
+ * reads — not merely self-consistent.
+ *
+ * The three [app.aaps.pump.carelevo.ble.BleClient] shapes are exercised the way the client drives them:
+ * - [app.aaps.pump.carelevo.ble.BleCommand] → `decode(frames.single())`
+ * - [app.aaps.pump.carelevo.ble.BleMultiCommand] → `decode(frames.associateBy { it[0] })` (keyed by opcode)
+ * - [app.aaps.pump.carelevo.ble.BleStreamCommand]→ decode each frame, terminate on `isTerminal(decoded)`
+ *
+ * Pure JVM: the emulator takes a nullable logger and touches no Android API, so no Robolectric.
+ */
+class CarelevoPumpEmulatorTest {
+
+ private lateinit var state: CarelevoPumpState
+ private lateinit var emulator: CarelevoPumpEmulator
+
+ @BeforeEach
+ fun setUp() {
+ state = CarelevoPumpState()
+ emulator = CarelevoPumpEmulator(state)
+ }
+
+ // ---- Pairing ---------------------------------------------------------------------------------
+
+ @Test
+ fun `mac address round-trip decodes the patch address and checksum`() {
+ val cmd = MacAddressCommand(MAC_KEY.toByte())
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ assertThat(frames.single()[0]).isEqualTo(MacAddressCommand.RESPONSE_OPCODE)
+ assertThat(decoded.macAddress).isEqualTo("94B2161D2F6D")
+ assertThat(decoded.checkSum).isEqualTo("5A")
+ // The key must be retained — 0x4B verifies the app's fold against it.
+ assertThat(state.lastMacKey).isEqualTo(MAC_KEY)
+ }
+
+ @Test
+ fun `app auth accepts the checksum fold the session computes`() {
+ val macResponse = readMac(MAC_KEY)
+ val cmd = AppAuthCommand(sessionFold(macResponse, MAC_KEY))
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ assertThat(decoded.resultCode).isEqualTo(0)
+ }
+
+ @Test
+ fun `app auth rejects a wrong checksum`() {
+ val macResponse = readMac(MAC_KEY)
+ // One bit off the fold the patch expects — a real patch rejects this, so the emulator must too.
+ val cmd = AppAuthCommand((sessionFold(macResponse, MAC_KEY) + 1) and 0xFF)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ assertThat(decoded.resultCode).isNotEqualTo(0)
+ }
+
+ @Test
+ fun `app auth before the mac read fails`() {
+ // No 0x3B first, so the patch has no key to verify against.
+ val cmd = AppAuthCommand(0x42)
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.resultCode).isNotEqualTo(0)
+ }
+
+ @Test
+ fun `app auth answers on 0xBB not 0x4B 0xBA or 0xAB`() {
+ val macResponse = readMac(MAC_KEY)
+ val cmd = AppAuthCommand(sessionFold(macResponse, MAC_KEY))
+
+ val opcode = emulator.handle(cmd.encode()).single()[0]
+
+ assertThat(opcode).isEqualTo(0xBB.toByte())
+ assertThat(opcode).isNotEqualTo(0x4B.toByte())
+ assertThat(opcode).isNotEqualTo(0xBA.toByte())
+ assertThat(opcode).isNotEqualTo(0xAB.toByte())
+ // ...and the production decoder agrees, since it requires 0xBB at byte 0.
+ assertThat(cmd.decode(emulator.handle(cmd.encode()).single()).resultCode).isEqualTo(0)
+ }
+
+ @Test
+ fun `app auth result code override wins over a correct fold`() {
+ val macResponse = readMac(MAC_KEY)
+ state.resultCodeOverrides[CarelevoPumpEmulator.OP_APP_AUTH] = 2
+ val cmd = AppAuthCommand(sessionFold(macResponse, MAC_KEY))
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.resultCode).isEqualTo(2)
+ }
+
+ // ---- The swapped needle pair -----------------------------------------------------------------
+
+ @Test
+ fun `needle ack 0x19 answers on 0x7A not 0x79`() {
+ val cmd = NeedleAckCommand(isSuccess = true)
+
+ val frames = emulator.handle(cmd.encode())
+
+ // A "+0x60" emulator would answer 0x79 here and deadlock the client.
+ assertThat(frames.single()[0]).isEqualTo(0x7A.toByte())
+ assertThat(frames.single()[0]).isNotEqualTo(0x79.toByte())
+ assertThat(cmd.decode(frames.single()).resultCode).isEqualTo(0)
+ assertThat(state.needleInserted).isTrue()
+ }
+
+ @Test
+ fun `needle status 0x1A answers on 0x79 not 0x7A`() {
+ val cmd = NeedleStatusCommand()
+
+ val frames = emulator.handle(cmd.encode())
+
+ assertThat(frames.single()[0]).isEqualTo(0x79.toByte())
+ assertThat(frames.single()[0]).isNotEqualTo(0x7A.toByte())
+ assertThat(cmd.decode(frames.single()).resultCode).isEqualTo(0)
+ }
+
+ @Test
+ fun `needle ack with the failure flag leaves the needle uninserted`() {
+ val cmd = NeedleAckCommand(isSuccess = false)
+
+ cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(state.needleInserted).isFalse()
+ }
+
+ // ---- Patch info ------------------------------------------------------------------------------
+
+ @Test
+ fun `patch info answers with exactly the two report frames 0x93 and 0x94`() {
+ val cmd = PatchInfoCommand()
+
+ val frames = emulator.handle(cmd.encode())
+
+ assertThat(frames.map { it[0] }).containsExactly(0x93.toByte(), 0x94.toByte())
+ assertThat(frames.map { it[0] }.toSet()).isEqualTo(cmd.expectedResponseOpcodes)
+ }
+
+ @Test
+ fun `patch info round-trip decodes serial firmware and the decimal-concat model name`() {
+ val cmd = PatchInfoCommand()
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).associateBy { it[0] })
+
+ assertThat(decoded.serialResultCode).isEqualTo(0)
+ assertThat(decoded.serialNumber).isEqualTo("CL24000000001")
+ assertThat(decoded.detailResultCode).isEqualTo(0)
+ assertThat(decoded.firmwareVersion).isEqualTo("1.10")
+ // The quirk: model bytes are concatenated DECIMAL values, not ASCII — [1,2,0,0,0] -> "12000".
+ assertThat(decoded.modelName).isEqualTo("12000")
+ }
+
+ @Test
+ fun `patch info model name follows the state model bytes`() {
+ state.modelBytes = byteArrayOf(2, 15, 0, 3, 0)
+ val cmd = PatchInfoCommand()
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).associateBy { it[0] })
+
+ assertThat(decoded.modelName).isEqualTo("215030")
+ }
+
+ // ---- SetTime split ---------------------------------------------------------------------------
+
+ @Test
+ fun `set time with subId 0 answers with the patch info pair`() {
+ val cmd = SetTimeForPatchInfoCommand(subId = 0, volume = 200, aidMode = 0, dateTime = DATE_TIME)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.associateBy { it[0] })
+
+ // The activation path waits for 0x93+0x94; a 0x71 here would hang it.
+ assertThat(frames.map { it[0] }).containsExactly(0x93.toByte(), 0x94.toByte())
+ assertThat(decoded.serialNumber).isEqualTo("CL24000000001")
+ }
+
+ @Test
+ fun `set time with a non-zero subId answers on 0x71`() {
+ val cmd = SetTimeCommand(subId = 1, volume = 200, aidMode = 0, dateTime = DATE_TIME)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ assertThat(frames.single()[0]).isEqualTo(SetTimeCommand.RESPONSE_OPCODE)
+ assertThat(decoded.resultCode).isEqualTo(0)
+ }
+
+ @Test
+ fun `set time frames differ only in the subId byte`() {
+ val forPatchInfo = SetTimeForPatchInfoCommand(subId = 0, volume = 200, aidMode = 0, dateTime = DATE_TIME).encode()
+ val plain = SetTimeCommand(subId = 1, volume = 200, aidMode = 0, dateTime = DATE_TIME).encode()
+
+ // Byte-identical 11-byte frames on one opcode — only byte 1 tells the two commands apart,
+ // which is exactly why the emulator has to branch on it.
+ assertThat(forPatchInfo).hasLength(CarelevoPumpEmulator.SET_TIME_LENGTH)
+ assertThat(plain).hasLength(CarelevoPumpEmulator.SET_TIME_LENGTH)
+ assertThat(forPatchInfo[0]).isEqualTo(plain[0])
+ assertThat(forPatchInfo[1]).isNotEqualTo(plain[1])
+ assertThat(forPatchInfo.copyOfRange(2, forPatchInfo.size))
+ .isEqualTo(plain.copyOfRange(2, plain.size))
+ }
+
+ @Test
+ fun `set time records the subId and resets the running minutes`() {
+ state.runningMinutes = 500
+ val cmd = SetTimeCommand(subId = 1, volume = 150, aidMode = 0, dateTime = DATE_TIME)
+
+ cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(state.subId).isEqualTo(1)
+ assertThat(state.runningMinutes).isEqualTo(0)
+ }
+
+ // ---- Safety check stream ---------------------------------------------------------------------
+
+ @Test
+ fun `safety check streams progress frames then a terminal frame`() {
+ state.safetyCheckProgressFrames = 3
+ val cmd = SafetyCheckCommand()
+
+ val decodedFrames = emulator.handle(cmd.encode()).map { cmd.decode(it) }
+
+ assertThat(decodedFrames).hasSize(4)
+ assertThat(decodedFrames.dropLast(1).map { cmd.isTerminal(it) }).containsExactly(false, false, false)
+ assertThat(decodedFrames.last().resultCode).isEqualTo(SafetyCheckCommand.RESULT_SUCCESS)
+ assertThat(cmd.isTerminal(decodedFrames.last())).isTrue()
+ }
+
+ @Test
+ fun `safety check progress frames carry a progress result code`() {
+ val cmd = SafetyCheckCommand()
+
+ val decodedFrames = emulator.handle(cmd.encode()).map { cmd.decode(it) }
+
+ // Progress is signalled purely by the result byte being REP_REQUEST/REP_REQUEST1.
+ assertThat(decodedFrames.dropLast(1).map { it.resultCode })
+ .containsExactly(SafetyCheckCommand.REP_REQUEST, SafetyCheckCommand.REP_REQUEST)
+ }
+
+ @Test
+ fun `safety check never emits a 5-byte frame`() {
+ state.safetyCheckProgressFrames = 4
+ val cmd = SafetyCheckCommand()
+
+ val frames = emulator.handle(cmd.encode())
+
+ // SafetyCheckCommand.decode reads index 5 whenever size > 4, so a 5-byte frame would throw
+ // ArrayIndexOutOfBounds in the real driver instead of failing cleanly.
+ assertThat(frames.map { it.size }).doesNotContain(5)
+ assertThat(frames.map { it.size }.all { it == 4 || it >= 6 }).isTrue()
+ assertThat(frames.map { it[0] }.toSet()).containsExactly(SafetyCheckCommand.RESPONSE_OPCODE)
+ }
+
+ @Test
+ fun `safety check frames decode the priming volume and duration`() {
+ state.safetyCheckVolume = 250
+ state.safetyCheckDurationSeconds = 185
+ val cmd = SafetyCheckCommand()
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).last())
+
+ assertThat(decoded.insulinVolume).isEqualTo(250)
+ assertThat(decoded.durationSeconds).isEqualTo(185)
+ }
+
+ @Test
+ fun `safety check success moves the patch to RUNNING`() {
+ state.pumpStateRaw = CarelevoPumpEmulator.PUMP_STATE_READY
+ val cmd = SafetyCheckCommand()
+
+ cmd.decode(emulator.handle(cmd.encode()).last())
+
+ assertThat(state.pumpStateRaw).isEqualTo(CarelevoPumpEmulator.PUMP_STATE_RUNNING)
+ }
+
+ @Test
+ fun `safety check error terminates the stream and leaves the pump state alone`() {
+ state.pumpStateRaw = CarelevoPumpEmulator.PUMP_STATE_READY
+ state.safetyCheckResult = 11
+ val cmd = SafetyCheckCommand()
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).last())
+
+ // An error code is terminal too — the stream must complete rather than time out.
+ assertThat(cmd.isTerminal(decoded)).isTrue()
+ assertThat(decoded.resultCode).isEqualTo(11)
+ assertThat(state.pumpStateRaw).isEqualTo(CarelevoPumpEmulator.PUMP_STATE_READY)
+ }
+
+ @Test
+ fun `safety check with no progress frames emits only the terminal frame`() {
+ state.safetyCheckProgressFrames = 0
+ val cmd = SafetyCheckCommand()
+
+ val frames = emulator.handle(cmd.encode())
+
+ assertThat(frames).hasSize(1)
+ assertThat(cmd.isTerminal(cmd.decode(frames.single()))).isTrue()
+ }
+
+ // ---- Immediate bolus -------------------------------------------------------------------------
+
+ @Test
+ fun `immediate bolus round-trip echoes the action id and decodes the remaining reservoir`() {
+ val cmd = ImmediateBolusCommand(actionId = 42, volume = 2.5)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ assertThat(frames.single()[0]).isEqualTo(ImmediateBolusCommand.RESPONSE_OPCODE)
+ // Byte 1 is the correlation byte — the client silently drops a frame that does not match.
+ assertThat(frames.single()[1]).isEqualTo(cmd.correlationByte)
+ assertThat(decoded.actionId).isEqualTo(42)
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(decoded.expectedCompletionSeconds).isEqualTo(50)
+ assertThat(decoded.remainingReservoirUnits).isWithin(TOLERANCE).of(197.5)
+ }
+
+ @Test
+ fun `immediate bolus echoes an action id above 127 unsigned`() {
+ val cmd = ImmediateBolusCommand(actionId = 200, volume = 1.0)
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.actionId).isEqualTo(200)
+ assertThat(state.activeBolusActionId).isEqualTo(200)
+ }
+
+ @Test
+ fun `immediate bolus decrements the reservoir and adds to the bolus total`() {
+ state.insulinRemaining = 100.0
+ state.infusedTotalBolus = 3.0
+ val cmd = ImmediateBolusCommand(actionId = 7, volume = 4.25)
+
+ cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(state.insulinRemaining).isWithin(TOLERANCE).of(95.75)
+ assertThat(state.infusedTotalBolus).isWithin(TOLERANCE).of(7.25)
+ assertThat(state.modeRaw).isEqualTo(CarelevoPumpEmulator.MODE_IMME_BOLUS)
+ // The emulated bolus lands immediately, so the whole dose is already infused — a later cancel
+ // reports this, rather than claiming 0 U for insulin the totals above have already counted.
+ assertThat(state.bolusInfusedAmount).isWithin(TOLERANCE).of(4.25)
+ }
+
+ @Test
+ fun `immediate bolus failure keeps the reservoir and still echoes the action id`() {
+ state.resultCodeOverrides[CarelevoPumpEmulator.OP_IMMEDIATE_BOLUS] = 6
+ val cmd = ImmediateBolusCommand(actionId = 99, volume = 3.0)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ // Result code lives at index 2 — index 1 is the echoed actionId, not the result.
+ assertThat(frames.single()[2]).isEqualTo(6.toByte())
+ assertThat(decoded.resultCode).isEqualTo(6)
+ assertThat(decoded.actionId).isEqualTo(99)
+ assertThat(state.insulinRemaining).isWithin(TOLERANCE).of(200.0)
+ assertThat(state.activeBolusActionId).isNull()
+ }
+
+ // ---- Infusion info ---------------------------------------------------------------------------
+
+ @Test
+ fun `infusion info frame is 20 bytes and echoes the inquiry type`() {
+ val cmd = InfusionInfoCommand(inquiryType = 1)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ // The decoder reads index 19, so anything shorter than 20 fails the require().
+ assertThat(frames.single().size).isAtLeast(20)
+ assertThat(frames.single()[0]).isEqualTo(InfusionInfoCommand.RESPONSE_OPCODE)
+ assertThat(decoded.subId).isEqualTo(1)
+ }
+
+ @Test
+ fun `infusion info round-trip decodes every field`() {
+ state.runningMinutes = 125
+ state.insulinRemaining = 187.65
+ state.infusedTotalBasal = 12.34
+ state.infusedTotalBolus = 5.5
+ state.pumpStateRaw = CarelevoPumpEmulator.PUMP_STATE_RUNNING
+ state.modeRaw = CarelevoPumpEmulator.MODE_BASAL
+ val cmd = InfusionInfoCommand()
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.subId).isEqualTo(0)
+ assertThat(decoded.runningMinutes).isEqualTo(125)
+ assertThat(decoded.insulinRemaining).isWithin(TOLERANCE).of(187.65)
+ assertThat(decoded.infusedTotalBasalAmount).isWithin(TOLERANCE).of(12.34)
+ assertThat(decoded.infusedTotalBolusAmount).isWithin(TOLERANCE).of(5.5)
+ assertThat(decoded.pumpStateRaw).isEqualTo(2)
+ assertThat(decoded.modeRaw).isEqualTo(1)
+ assertThat(decoded.currentInfusedProgramVolume).isWithin(TOLERANCE).of(5.5)
+ // realInfusedTime is seconds: 125 min -> 7500 s.
+ assertThat(decoded.realInfusedTime).isEqualTo(7500)
+ }
+
+ // ---- Basal program ---------------------------------------------------------------------------
+
+ @Test
+ fun `basal program acks each sequence individually and commits only on seq 2`() {
+ val seq0 = BasalProgramCommand(isUpdate = false, seqNo = 0, segmentSpeeds = listOf(0.5, 0.75))
+ val seq1 = BasalProgramCommand(isUpdate = false, seqNo = 1, segmentSpeeds = listOf(1.25, 1.5))
+ val seq2 = BasalProgramCommand(isUpdate = false, seqNo = 2, segmentSpeeds = listOf(2.0, 2.5))
+
+ assertThat(seq0.decode(emulator.handle(seq0.encode()).single()).resultCode).isEqualTo(0)
+ assertThat(state.basalProgramCommitted).isFalse()
+
+ assertThat(seq1.decode(emulator.handle(seq1.encode()).single()).resultCode).isEqualTo(0)
+ assertThat(state.basalProgramCommitted).isFalse()
+
+ assertThat(seq2.decode(emulator.handle(seq2.encode()).single()).resultCode).isEqualTo(0)
+ assertThat(state.basalProgramCommitted).isTrue()
+ }
+
+ @Test
+ fun `basal program returns the segments in sequence order`() {
+ listOf(
+ BasalProgramCommand(isUpdate = false, seqNo = 2, segmentSpeeds = listOf(2.0, 2.5)),
+ BasalProgramCommand(isUpdate = false, seqNo = 0, segmentSpeeds = listOf(0.5, 0.75)),
+ BasalProgramCommand(isUpdate = false, seqNo = 1, segmentSpeeds = listOf(1.25, 1.5))
+ ).forEach { cmd -> cmd.decode(emulator.handle(cmd.encode()).single()) }
+
+ // Written out of order; the program still reads back in segment order.
+ assertThat(state.basalProgram).containsExactly(0.5, 0.75, 1.25, 1.5, 2.0, 2.5).inOrder()
+ }
+
+ @Test
+ fun `basal program set uses 0x13 to 0x73 and update uses 0x21 to 0x81`() {
+ val set = BasalProgramCommand(isUpdate = false, seqNo = 0, segmentSpeeds = listOf(1.0))
+ val update = BasalProgramCommand(isUpdate = true, seqNo = 0, segmentSpeeds = listOf(1.0))
+
+ val setFrame = emulator.handle(set.encode()).single()
+ val updateFrame = emulator.handle(update.encode()).single()
+
+ assertThat(set.encode()[0]).isEqualTo(BasalProgramCommand.SET_REQUEST_OPCODE)
+ assertThat(setFrame[0]).isEqualTo(BasalProgramCommand.SET_RESPONSE_OPCODE)
+ assertThat(update.encode()[0]).isEqualTo(BasalProgramCommand.UPDATE_REQUEST_OPCODE)
+ assertThat(updateFrame[0]).isEqualTo(BasalProgramCommand.UPDATE_RESPONSE_OPCODE)
+ assertThat(set.decode(setFrame).resultCode).isEqualTo(0)
+ assertThat(update.decode(updateFrame).resultCode).isEqualTo(0)
+ }
+
+ @Test
+ fun `basal program failure does not bank the segments`() {
+ state.resultCodeOverrides[BasalProgramCommand.SET_REQUEST_OPCODE] = 9
+ val cmd = BasalProgramCommand(isUpdate = false, seqNo = 2, segmentSpeeds = listOf(1.0, 2.0))
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.resultCode).isEqualTo(9)
+ assertThat(state.basalProgramCommitted).isFalse()
+ assertThat(state.basalProgram).isEmpty()
+ }
+
+ // ---- Index-shifted result codes ---------------------------------------------------------------
+
+ @Test
+ fun `infusion threshold carries its result at index 2 behind the echoed type`() {
+ state.resultCodeOverrides[CarelevoPumpEmulator.OP_INFUSION_THRESHOLD] = 3
+ val cmd = InfusionThresholdCommand(isMaxVolume = true, value = 12.5)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ // Byte 1 echoes the type flag, so the result sits at index 2 — not the usual index 1.
+ assertThat(frames.single()[1]).isEqualTo(0x01.toByte())
+ assertThat(frames.single()[2]).isEqualTo(3.toByte())
+ assertThat(decoded.type).isEqualTo(1)
+ assertThat(decoded.resultCode).isEqualTo(3)
+ }
+
+ @Test
+ fun `infusion threshold max volume round-trip stores the max bolus dose`() {
+ val cmd = InfusionThresholdCommand(isMaxVolume = true, value = 12.5)
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.type).isEqualTo(1)
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(state.maxBolusDose).isWithin(TOLERANCE).of(12.5)
+ }
+
+ @Test
+ fun `infusion threshold max speed round-trip stores the max basal speed`() {
+ val cmd = InfusionThresholdCommand(isMaxVolume = false, value = 3.75)
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.type).isEqualTo(0)
+ assertThat(state.maxBasalSpeed).isWithin(TOLERANCE).of(3.75)
+ }
+
+ @Test
+ fun `alarm clear carries its result at index 3 behind the echoed type and cause`() {
+ state.resultCodeOverrides[CarelevoPumpEmulator.OP_ALARM_CLEAR] = 4
+ val cmd = AlarmClearCommand(alarmType = 5, cause = 3)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ assertThat(frames.single()[0]).isEqualTo(AlarmClearCommand.RESPONSE_OPCODE)
+ assertThat(frames.single()[3]).isEqualTo(4.toByte())
+ assertThat(decoded.subId).isEqualTo(5)
+ assertThat(decoded.cause).isEqualTo(3)
+ assertThat(decoded.resultCode).isEqualTo(4)
+ }
+
+ @Test
+ fun `notice threshold echoes the type with no result code on the wire`() {
+ val lowInsulin = NoticeThresholdCommand(thresholdType = NoticeThresholdCommand.TYPE_LOW_INSULIN, value = 35)
+ val expiry = NoticeThresholdCommand(thresholdType = NoticeThresholdCommand.TYPE_EXPIRY, value = 48)
+
+ val lowFrame = emulator.handle(lowInsulin.encode()).single()
+ val expiryFrame = emulator.handle(expiry.encode()).single()
+
+ // The 0x75 frame is [opcode][type] — arrival IS the success signal; resultCode is fabricated.
+ assertThat(lowFrame).hasLength(2)
+ assertThat(lowFrame[1]).isEqualTo(0x00.toByte())
+ assertThat(expiryFrame[1]).isEqualTo(0x01.toByte())
+ assertThat(lowInsulin.decode(lowFrame).thresholdType).isEqualTo(NoticeThresholdCommand.TYPE_LOW_INSULIN)
+ assertThat(lowInsulin.decode(lowFrame).resultCode).isEqualTo(0)
+ assertThat(expiry.decode(expiryFrame).thresholdType).isEqualTo(NoticeThresholdCommand.TYPE_EXPIRY)
+ assertThat(state.lowInsulinNotice).isEqualTo(35)
+ assertThat(state.expiryNotice).isEqualTo(48)
+ }
+
+ // ---- Remaining opcodes ------------------------------------------------------------------------
+
+ @Test
+ fun `buzz mode round-trip stores the buzzer flag`() {
+ val on = BuzzModeCommand(use = true)
+ assertThat(on.decode(emulator.handle(on.encode()).single()).resultCode).isEqualTo(0)
+ assertThat(state.buzzUse).isTrue()
+
+ val off = BuzzModeCommand(use = false)
+ assertThat(off.decode(emulator.handle(off.encode()).single()).resultCode).isEqualTo(0)
+ assertThat(state.buzzUse).isFalse()
+ }
+
+ @Test
+ fun `threshold setup round-trip stores the whole activation bundle`() {
+ val cmd = ThresholdSetupCommand(
+ insulinRemainsThreshold = 30,
+ expiryThreshold = 48,
+ maxBasalSpeed = 10.5,
+ maxBolusDose = 20.25,
+ buzzUse = true
+ )
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(state.insulinRemainsThreshold).isEqualTo(30)
+ assertThat(state.expiryThreshold).isEqualTo(48)
+ assertThat(state.maxBasalSpeed).isWithin(TOLERANCE).of(10.5)
+ assertThat(state.maxBolusDose).isWithin(TOLERANCE).of(20.25)
+ assertThat(state.buzzUse).isTrue()
+ }
+
+ @Test
+ fun `additional priming round-trip counts the priming pulse`() {
+ val cmd = AdditionalPrimingCommand()
+
+ assertThat(cmd.decode(emulator.handle(cmd.encode()).single()).resultCode).isEqualTo(0)
+ cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(state.primingCount).isEqualTo(2)
+ }
+
+ @Test
+ fun `temp basal by unit round-trip starts the temp basal`() {
+ val cmd = TempBasalCommand.byUnit(infusionUnit = 1.5, infusionHour = 2, infusionMin = 30)
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(cmd.encode()).hasLength(6) // BY_UNIT carries the trailing 0x00
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(state.tempBasalRunning).isTrue()
+ assertThat(state.modeRaw).isEqualTo(CarelevoPumpEmulator.MODE_TEMP_BASAL)
+ }
+
+ @Test
+ fun `temp basal by percent round-trip uses the same opcode pair`() {
+ val cmd = TempBasalCommand.byPercent(infusionPercent = 150, infusionHour = 1, infusionMin = 0)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ assertThat(cmd.encode()).hasLength(5) // BY_PERCENT has no trailing byte — the asymmetry
+ assertThat(frames.single()[0]).isEqualTo(TempBasalCommand.RESPONSE_OPCODE)
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(state.tempBasalRunning).isTrue()
+ }
+
+ @Test
+ fun `temp basal cancel round-trip stops the temp basal`() {
+ state.tempBasalRunning = true
+ state.modeRaw = CarelevoPumpEmulator.MODE_TEMP_BASAL
+ val cmd = TempBasalCancelCommand()
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(state.tempBasalRunning).isFalse()
+ assertThat(state.modeRaw).isEqualTo(CarelevoPumpEmulator.MODE_BASAL)
+ }
+
+ @Test
+ fun `extend bolus round-trip starts the extended bolus`() {
+ val cmd = ExtendBolusCommand(immediateDose = 1.0, extendedSpeed = 0.5, hour = 1, min = 30)
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.resultCode).isEqualTo(0)
+ // The decoder recombines bytes 2..3 as `[2] * 60 + [3]` seconds, so a 1h30m request must come
+ // back as 5400 s — encoded [90, 0], with the minutes in byte 2 rather than split again by 60.
+ assertThat(decoded.expectedTimeSeconds).isEqualTo(5400)
+ assertThat(state.extendedBolusRunning).isTrue()
+ assertThat(state.modeRaw).isEqualTo(CarelevoPumpEmulator.MODE_EXTEND_BOLUS)
+ }
+
+ @Test
+ fun `extend bolus cancel round-trip reports the infused amount`() {
+ state.extendedBolusRunning = true
+ state.extendedInfusedAmount = 3.25
+ val cmd = ExtendBolusCancelCommand()
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(decoded.infusedAmount).isWithin(TOLERANCE).of(3.25)
+ assertThat(state.extendedBolusRunning).isFalse()
+ assertThat(state.modeRaw).isEqualTo(CarelevoPumpEmulator.MODE_BASAL)
+ }
+
+ @Test
+ fun `bolus cancel round-trip reports the infused amount and clears the action id`() {
+ state.activeBolusActionId = 42
+ state.bolusInfusedAmount = 1.75
+ val cmd = BolusCancelCommand()
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(decoded.infusedAmount).isWithin(TOLERANCE).of(1.75)
+ assertThat(state.activeBolusActionId).isNull()
+ assertThat(state.modeRaw).isEqualTo(CarelevoPumpEmulator.MODE_BASAL)
+ }
+
+ @Test
+ fun `pump stop round-trip stops the patch and records the subId`() {
+ val cmd = PumpStopCommand(durationMinutes = 90, subId = 1)
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(state.stopped).isTrue()
+ assertThat(state.subId).isEqualTo(1)
+ }
+
+ @Test
+ fun `pump resume round-trip echoes the mode and defaults the optional subId`() {
+ state.stopped = true
+ val cmd = PumpResumeCommand(mode = 1, subId = 1)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ // The 4th subId byte is omitted; the decoder must default it rather than fail.
+ assertThat(frames.single()).hasLength(3)
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(decoded.mode).isEqualTo(1)
+ assertThat(decoded.subId).isEqualTo(0)
+ assertThat(state.stopped).isFalse()
+ assertThat(state.modeRaw).isEqualTo(CarelevoPumpEmulator.MODE_BASAL)
+ }
+
+ @Test
+ fun `patch discard round-trip discards the patch and returns it to READY`() {
+ val cmd = PatchDiscardCommand()
+
+ val decoded = cmd.decode(emulator.handle(cmd.encode()).single())
+
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(state.discarded).isTrue()
+ assertThat(state.pumpStateRaw).isEqualTo(CarelevoPumpEmulator.PUMP_STATE_READY)
+ }
+
+ @Test
+ fun `alert alarm set round-trip stores the alarm mode`() {
+ val cmd = AlertAlarmSetCommand(mode = 3)
+
+ val frames = emulator.handle(cmd.encode())
+ val decoded = cmd.decode(frames.single())
+
+ assertThat(frames.single()[0]).isEqualTo(AlertAlarmSetCommand.RESPONSE_OPCODE)
+ assertThat(decoded.resultCode).isEqualTo(0)
+ assertThat(state.alertAlarmMode).isEqualTo(3)
+ }
+
+ // ---- Fault injection --------------------------------------------------------------------------
+
+ @Test
+ fun `silent opcodes make the patch stay quiet`() {
+ state.silentOpcodes += InfusionInfoCommand.REQUEST_OPCODE
+ val silent = InfusionInfoCommand()
+ val loud = PatchDiscardCommand()
+
+ assertThat(emulator.handle(silent.encode())).isEmpty()
+ // ...and only that opcode goes quiet.
+ assertThat(emulator.handle(loud.encode())).hasSize(1)
+ }
+
+ @Test
+ fun `result code overrides come back through the real decoder`() {
+ state.resultCodeOverrides[CarelevoPumpEmulator.OP_PUMP_STOP] = 12
+ state.resultCodeOverrides[CarelevoPumpEmulator.OP_PATCH_DISCARD] = 7
+ val stop = PumpStopCommand(durationMinutes = 30, subId = 0)
+ val discard = PatchDiscardCommand()
+
+ assertThat(stop.decode(emulator.handle(stop.encode()).single()).resultCode).isEqualTo(12)
+ assertThat(discard.decode(emulator.handle(discard.encode()).single()).resultCode).isEqualTo(7)
+ // A non-success result must not apply the state mutation.
+ assertThat(state.stopped).isFalse()
+ assertThat(state.discarded).isFalse()
+ }
+
+ @Test
+ fun `silent opcode wins over a result code override`() {
+ state.silentOpcodes += CarelevoPumpEmulator.OP_PATCH_DISCARD
+ state.resultCodeOverrides[CarelevoPumpEmulator.OP_PATCH_DISCARD] = 7
+
+ assertThat(emulator.handle(PatchDiscardCommand().encode())).isEmpty()
+ }
+
+ // ---- Malformed input --------------------------------------------------------------------------
+
+ @Test
+ fun `empty request is ignored`() {
+ assertThat(emulator.handle(ByteArray(0))).isEmpty()
+ }
+
+ @Test
+ fun `unknown opcode is ignored`() {
+ assertThat(emulator.handle(byteArrayOf(0x7F, 0x01, 0x02))).isEmpty()
+ }
+
+ // ---- Helpers ----------------------------------------------------------------------------------
+
+ /** Runs the real 0x3B round-trip and returns the decoded response. */
+ private fun readMac(key: Int): MacAddressResponse {
+ val cmd = MacAddressCommand(key.toByte())
+ return cmd.decode(emulator.handle(cmd.encode()).single())
+ }
+
+ /**
+ * The app-side handshake fold, exactly as `CarelevoBleSession.runPairing` computes it:
+ * `(macResponse.macAddress + macResponse.checkSum).convertHexToByteArray().checkSumV2(key)`.
+ *
+ * `convertHexToByteArray`/`checkSumV2` are `internal` to `:pump:carelevo`, and Kotlin only grants
+ * internal visibility to a module's own test source set — so this module cannot call them and the
+ * hex-parse + XOR fold is replicated here instead. Kept deliberately literal (parse the decoded
+ * hex strings, fold from `key.toByte()`) so it stays a faithful stand-in for the session's code.
+ */
+ private fun sessionFold(macResponse: MacAddressResponse, key: Int): Int =
+ (macResponse.macAddress + macResponse.checkSum)
+ .chunked(2)
+ .map { it.toInt(16).toByte() }
+ .fold(key.toByte()) { acc, b -> acc xor b }
+ .toUByte()
+ .toInt()
+
+ private companion object {
+
+ /** Above 127 on purpose — proves the key survives the Int→Byte→unsigned round-trip. */
+ const val MAC_KEY = 0xC3
+
+ val DATE_TIME: DateTime = DateTime(2026, 7, 16, 14, 30, 45)
+
+ const val TOLERANCE = 1e-9
+ }
+}
diff --git a/pump/carelevo/build.gradle.kts b/pump/carelevo/build.gradle.kts
new file mode 100644
index 000000000000..656fdddd19c4
--- /dev/null
+++ b/pump/carelevo/build.gradle.kts
@@ -0,0 +1,41 @@
+plugins {
+ alias(libs.plugins.android.library)
+ alias(libs.plugins.compose.compiler)
+ alias(libs.plugins.ksp)
+ alias(libs.plugins.hilt)
+ id("android-module-dependencies")
+ id("test-module-dependencies")
+ id("compose-test-module-dependencies")
+ id("jacoco-module-dependencies")
+}
+
+android {
+ namespace = "app.aaps.pump.carelevo"
+
+ buildFeatures {
+ compose = true
+ }
+}
+
+dependencies {
+ implementation(project(":core:data"))
+ implementation(project(":core:interfaces"))
+ implementation(project(":core:utils"))
+ implementation(project(":core:ui"))
+ implementation(project(":core:keys"))
+ implementation(libs.androidx.compose.ui.tooling.preview)
+ debugImplementation(libs.androidx.compose.ui.tooling)
+
+ implementation(libs.com.google.guava)
+ implementation(libs.androidx.lifecycle.process)
+ implementation(libs.io.reactivex.rxjava3.rxandroid)
+ implementation(libs.com.polidea.rxandroidble3)
+ implementation(libs.com.jakewharton.rx3.replaying.share)
+ implementation(libs.com.google.android.material)
+
+ implementation(libs.com.google.dagger.hilt.android)
+ implementation(libs.androidx.hilt.navigation.compose)
+ ksp(libs.com.google.dagger.compiler)
+ ksp(libs.com.google.dagger.hilt.compiler)
+ ksp(libs.com.google.dagger.android.processor)
+}
diff --git a/pump/carelevo/src/main/AndroidManifest.xml b/pump/carelevo/src/main/AndroidManifest.xml
new file mode 100644
index 000000000000..b20c45d1cc6a
--- /dev/null
+++ b/pump/carelevo/src/main/AndroidManifest.xml
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/CarelevoPumpPlugin.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/CarelevoPumpPlugin.kt
new file mode 100644
index 000000000000..bc1e9ba34f9c
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/CarelevoPumpPlugin.kt
@@ -0,0 +1,762 @@
+package app.aaps.pump.carelevo
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothManager
+import android.content.Context
+import android.content.IntentFilter
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.ProcessLifecycleOwner
+import app.aaps.core.data.plugin.PluginType
+import app.aaps.core.data.pump.defs.ManufacturerType
+import app.aaps.core.data.pump.defs.PumpDescription
+import app.aaps.core.data.pump.defs.PumpType
+import app.aaps.core.data.pump.defs.TimeChangeType
+import app.aaps.core.interfaces.configuration.Config
+import app.aaps.core.interfaces.configuration.ExternalOptions
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.plugin.PluginDescription
+import app.aaps.core.interfaces.profile.Profile
+import app.aaps.core.interfaces.profile.ProfileFunction
+import app.aaps.core.interfaces.protection.ProtectionCheck
+import app.aaps.core.interfaces.pump.BlePreCheck
+import app.aaps.core.interfaces.pump.DetailedBolusInfo
+import app.aaps.core.interfaces.pump.Pump
+import app.aaps.core.interfaces.pump.PumpEnactResult
+import app.aaps.core.interfaces.pump.PumpInsulin
+import app.aaps.core.interfaces.pump.PumpPluginBase
+import app.aaps.core.interfaces.pump.PumpProfile
+import app.aaps.core.interfaces.pump.PumpRate
+import app.aaps.core.interfaces.pump.PumpSync
+import app.aaps.core.interfaces.pump.defs.fillFor
+import app.aaps.core.interfaces.queue.CommandQueue
+import app.aaps.core.interfaces.queue.CustomCommand
+import app.aaps.core.interfaces.resources.ResourceHelper
+import app.aaps.core.interfaces.rx.AapsSchedulers
+import app.aaps.core.interfaces.sharedPreferences.SP
+import app.aaps.core.interfaces.ui.IconsProvider
+import app.aaps.core.interfaces.ui.UiInteraction
+import app.aaps.core.interfaces.utils.fabric.FabricPrivacy
+import app.aaps.core.keys.DoubleKey
+import app.aaps.core.keys.IntKey
+import app.aaps.core.keys.interfaces.Preferences
+import app.aaps.core.keys.interfaces.withEntries
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.core.ui.compose.icons.IcPluginCarelevo
+import app.aaps.core.ui.compose.preference.PreferenceSubScreenDef
+import app.aaps.pump.carelevo.ble.CarelevoBleSession
+import app.aaps.pump.carelevo.ble.data.BleState
+import app.aaps.pump.carelevo.ble.data.BondingState
+import app.aaps.pump.carelevo.ble.data.DeviceModuleState
+import app.aaps.pump.carelevo.ble.data.DeviceModuleState.Companion.codeToDeviceResult
+import app.aaps.pump.carelevo.ble.data.NotificationState
+import app.aaps.pump.carelevo.ble.data.PeripheralConnectionState
+import app.aaps.pump.carelevo.ble.data.ServiceDiscoverState
+import app.aaps.pump.carelevo.command.CarelevoActivationExecutor
+import app.aaps.pump.carelevo.command.CmdTimeZoneUpdate
+import app.aaps.pump.carelevo.command.CmdUpdateBuzzer
+import app.aaps.pump.carelevo.command.CmdUpdateExpiredThreshold
+import app.aaps.pump.carelevo.command.CmdUpdateLowInsulinNotice
+import app.aaps.pump.carelevo.command.CmdUpdateMaxBolus
+import app.aaps.pump.carelevo.common.CarelevoAlarmNotifier
+import app.aaps.pump.carelevo.common.CarelevoObserveReceiver
+import app.aaps.pump.carelevo.common.CarelevoPatch
+import app.aaps.pump.carelevo.common.keys.CarelevoBooleanPreferenceKey
+import app.aaps.pump.carelevo.common.keys.CarelevoIntPreferenceKey
+import app.aaps.pump.carelevo.common.model.PatchState
+import app.aaps.pump.carelevo.compose.CarelevoComposeContent
+import app.aaps.pump.carelevo.coordinator.CarelevoBasalProfileUpdateCoordinator
+import app.aaps.pump.carelevo.coordinator.CarelevoBolusCoordinator
+import app.aaps.pump.carelevo.coordinator.CarelevoConnectionCoordinator
+import app.aaps.pump.carelevo.coordinator.CarelevoSettingsCoordinator
+import app.aaps.pump.carelevo.coordinator.CarelevoTempBasalCoordinator
+import app.aaps.pump.carelevo.domain.model.alarm.CarelevoAlarmInfo
+import app.aaps.pump.carelevo.domain.model.infusion.CarelevoInfusionInfoDomainModel
+import app.aaps.pump.carelevo.domain.model.userSetting.CarelevoUserSettingInfoDomainModel
+import app.aaps.pump.carelevo.domain.type.AlarmType.Companion.isCritical
+import app.aaps.pump.carelevo.ext.transformNotificationStringResources
+import io.reactivex.rxjava3.core.Completable
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.kotlin.plusAssign
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
+import javax.inject.Provider
+import javax.inject.Singleton
+import kotlin.jvm.optionals.getOrNull
+
+@Singleton
+class CarelevoPumpPlugin @Inject constructor(
+ aapsLogger: AAPSLogger,
+ rh: ResourceHelper,
+ preferences: Preferences,
+ commandQueue: CommandQueue,
+ private val aapsSchedulers: AapsSchedulers,
+ private val sp: SP,
+ private val fabricPrivacy: FabricPrivacy,
+ private val profileFunction: ProfileFunction,
+ private val context: Context,
+ private val protectionCheck: ProtectionCheck,
+ private val blePreCheck: BlePreCheck,
+ private val iconsProvider: IconsProvider,
+ private val config: Config,
+ private val uiInteraction: UiInteraction,
+ private var pumpEnactResultProvider: Provider,
+ private val carelevoPatch: CarelevoPatch,
+
+ private val carelevoAlarmNotifier: CarelevoAlarmNotifier,
+ private val basalProfileUpdateCoordinator: CarelevoBasalProfileUpdateCoordinator,
+ private val bolusCoordinator: CarelevoBolusCoordinator,
+ private val tempBasalCoordinator: CarelevoTempBasalCoordinator,
+ private val connectionCoordinator: CarelevoConnectionCoordinator,
+ private val settingsCoordinator: CarelevoSettingsCoordinator,
+ private val activationExecutor: CarelevoActivationExecutor
+) : PumpPluginBase(
+ pluginDescription = PluginDescription()
+ .mainType(PluginType.PUMP)
+ .composeContent { _ ->
+ CarelevoComposeContent(
+ aapsLogger = aapsLogger,
+ carelevoAlarmNotifier = carelevoAlarmNotifier,
+ protectionCheck = protectionCheck,
+ blePreCheck = blePreCheck,
+ iconsProvider = iconsProvider,
+ config = config
+ )
+ }
+ .icon(IcPluginCarelevo)
+ .pluginName(R.string.carelevo)
+ .shortName(R.string.carelevo_shortname)
+ .description(R.string.carelevo_description),
+ ownPreferences = listOf(CarelevoBooleanPreferenceKey::class.java, CarelevoIntPreferenceKey::class.java),
+ aapsLogger, rh, preferences, commandQueue
+), Pump {
+
+ private var bleReceiverDisposable: Disposable? = null
+ private val pluginDisposable = CompositeDisposable()
+
+ private var _pumpType: PumpType = PumpType.CAREMEDI_CARELEVO
+ private val _pumpDescription = PumpDescription().fillFor(_pumpType)
+
+ private var scope: CoroutineScope? = null
+ private var lifecycleObserver: LifecycleEventObserver? = null
+
+ // Auto-resume watchdog cadence + safety margin: poll this often, and reconcile once the stop window has
+ // elapsed plus this margin (so the patch has actually auto-resumed before AAPS clears its suspend).
+ private val autoResumePollMs = 30_000L
+ private val autoResumeMarginMs = 30_000L
+
+ // The coroutine BLE session every pump op runs over. Field-injected — its @Inject constructor
+ // holds no eager BLE state.
+ @Inject lateinit var bleSession: CarelevoBleSession
+
+ override suspend fun onStart() {
+ super.onStart()
+
+ applyDefaultCageThresholdsIfNeeded()
+ registerPreferenceChangeObserver()
+ initializeOnStart()
+ registerBleReceiverIfNeeded()
+ startAlarmObserving()
+ startAutoResumeWatchdog()
+ // Consume patch-pushed frames (alarms, stop/basal-restart reports) whenever a session is open.
+ bleSession.unsolicitedHandler = carelevoPatch::onUnsolicited
+ }
+
+ override suspend fun onStop() {
+ super.onStop()
+ aapsLogger.debug(LTag.PUMP, "onStop called")
+ bleSession.unsolicitedHandler = null
+ settingsCoordinator.clearUserSettings(pluginDisposable)
+ pluginDisposable.clear()
+
+ // onStart/onStop run as separate, unjoined pluginScope coroutines (PluginBase), so a fast
+ // disable→re-enable can overlap them. Tear down only the generation captured here, and clear
+ // a field only if it still points at that generation — never clobber a scope/observer that a
+ // concurrent onStart may have just re-created (this fn suspends at withContext below).
+ val scopeToCancel = scope
+ val observerToRemove = lifecycleObserver
+
+ scopeToCancel?.cancel()
+ if (scope === scopeToCancel) scope = null
+
+ carelevoAlarmNotifier.stopObserving()
+
+ observerToRemove?.let { observer ->
+ withContext(Dispatchers.Main) {
+ ProcessLifecycleOwner.get().lifecycle.removeObserver(observer)
+ }
+ }
+ if (lifecycleObserver === observerToRemove) lifecycleObserver = null
+ }
+
+ private fun registerPreferenceChangeObserver() {
+ val newScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+ scope = newScope
+
+ // Settings pushes go through the queue (connect-before-execute) like every other patch op — a
+ // direct fire-and-forget write would silently fail while the pump idle-disconnects between commands.
+ preferences.observe(DoubleKey.SafetyMaxBolus)
+ .drop(1)
+ .onEach { commandQueue.customCommand(CmdUpdateMaxBolus(preferences.get(DoubleKey.SafetyMaxBolus))) }
+ .launchIn(newScope)
+
+ preferences.observe(CarelevoIntPreferenceKey.CARELEVO_PATCH_EXPIRATION_REMINDER_HOURS)
+ .drop(1)
+ .onEach {
+ val hours = sp.getInt(CarelevoIntPreferenceKey.CARELEVO_PATCH_EXPIRATION_REMINDER_HOURS.key, 0)
+ commandQueue.customCommand(CmdUpdateExpiredThreshold(hours))
+ }
+ .launchIn(newScope)
+
+ preferences.observe(CarelevoIntPreferenceKey.CARELEVO_LOW_INSULIN_EXPIRATION_REMINDER_HOURS)
+ .drop(1)
+ .onEach {
+ val hours = sp.getInt(CarelevoIntPreferenceKey.CARELEVO_LOW_INSULIN_EXPIRATION_REMINDER_HOURS.key, 0)
+ // Zero = reminder off; skip enqueuing so the pump isn't reconnected just to no-op.
+ if (hours != 0) commandQueue.customCommand(CmdUpdateLowInsulinNotice(hours))
+ }
+ .launchIn(newScope)
+
+ preferences.observe(CarelevoBooleanPreferenceKey.CARELEVO_BUZZER_REMINDER)
+ .drop(1)
+ .onEach {
+ val on = sp.getBoolean(CarelevoBooleanPreferenceKey.CARELEVO_BUZZER_REMINDER.key, false)
+ commandQueue.customCommand(CmdUpdateBuzzer(on))
+ }
+ .launchIn(newScope)
+
+ // Deferred settings-sync recovery: a max-bolus / low-insulin change that couldn't reach the patch
+ // (changed while offline, or during a bolus) leaves a needXSyncPatch flag on the stored user
+ // settings; when the patch is booted again, push it through the queue. The combiner is PURE and the
+ // enqueue runs on IO.
+ pluginDisposable += Observable.combineLatest(
+ carelevoPatch.patchState,
+ carelevoPatch.infusionInfo,
+ carelevoPatch.userSettingInfo
+ ) { state, infusion, setting ->
+ computeSettingsSyncNeed(state.getOrNull(), infusion.getOrNull(), setting.getOrNull())
+ }
+ .distinctUntilChanged()
+ .subscribeOn(aapsSchedulers.io)
+ .observeOn(aapsSchedulers.io)
+ .subscribe { need ->
+ newScope.launch {
+ need.maxBolusDose?.let { commandQueue.customCommand(CmdUpdateMaxBolus(it)) }
+ need.lowInsulinHours?.let { commandQueue.customCommand(CmdUpdateLowInsulinNotice(it)) }
+ }
+ }
+ }
+
+ /**
+ * Auto-resume watchdog. A timed pump-stop makes the patch auto-resume at the stop duration, but with
+ * per-op BLE sessions there is no live link to receive the patch's stop-report push, and a 0x91 status
+ * read does not carry the suspend flag — so `isStopped` would stay latched until an app-initiated resume
+ * (issue #4993).
+ *
+ * Implemented as a resilient periodic check rather than a one-shot timer, so it is robust to the failure
+ * modes a single fire-and-forget timer has:
+ * - Each tick is independently guarded, so a transient reconcile failure neither kills the watchdog
+ * (it simply retries next tick) nor is permanent.
+ * - Elapsed time is measured from a DURABLE anchor ([CarelevoBasalInfusionInfoDomainModel.updatedAt],
+ * persisted at stop time and untouched by 0x91 status reads), so an app restart mid-stop still
+ * resumes on schedule instead of re-arming a full window.
+ * - A status read that momentarily resurrects `isStopped` is re-cleared on the next tick, because the
+ * anchor is stable.
+ */
+ private fun startAutoResumeWatchdog() {
+ scope?.launch {
+ while (isActive) {
+ try {
+ checkAutoResume()
+ } catch (e: CancellationException) {
+ throw e
+ } catch (e: Throwable) {
+ aapsLogger.error(LTag.PUMPCOMM, "auto-resume check failed (will retry)", e)
+ }
+ delay(autoResumePollMs)
+ }
+ }
+ }
+
+ /** One watchdog tick: reconcile a timed stop whose window has elapsed. Idempotent — safe to call repeatedly. */
+ private suspend fun checkAutoResume() {
+ val patchInfo = carelevoPatch.patchInfo.value?.getOrNull() ?: return
+ if (patchInfo.isStopped != true) return
+ val stopMinutes = patchInfo.stopMinutes ?: return
+ if (stopMinutes <= 0) return
+ // Durable stop-start anchor: basalInfusionInfo.updatedAt is set at persistStopped, survives an app
+ // restart (persisted), and is not moved by 0x91 status reads (which only rewrite patchInfo). Skip
+ // until infusion info is loaded.
+ val stopStartedAt = carelevoPatch.infusionInfo.value?.getOrNull()?.basalInfusionInfo?.updatedAt?.millis ?: return
+ val elapsedMs = System.currentTimeMillis() - stopStartedAt
+ if (elapsedMs < stopMinutes * 60_000L + autoResumeMarginMs) return
+ aapsLogger.info(LTag.PUMPCOMM, "auto-resume: ${stopMinutes}min stop elapsed (${elapsedMs / 1000}s) -> reconcile")
+ carelevoPatch.reconcileAutoResumed()
+ commandQueue.readStatus("Carelevo auto-resume")
+ }
+
+ private data class SettingsSyncNeed(val maxBolusDose: Double?, val lowInsulinHours: Int?)
+
+ /** Pure: which deferred patch settings still need pushing (flag set AND the patch is booted). */
+ private fun computeSettingsSyncNeed(
+ state: PatchState?,
+ infusion: CarelevoInfusionInfoDomainModel?,
+ setting: CarelevoUserSettingInfoDomainModel?
+ ): SettingsSyncNeed {
+ if (state !is PatchState.ConnectedBooted || setting == null) return SettingsSyncNeed(null, null)
+ // Max-bolus is a device safety cap — do not re-push mid-bolus (mirrors the use case's own guard).
+ // "No bolus running" requires BOTH channels idle (the deleted observeSyncPatch had this as `||`,
+ // which was true during a single-channel bolus and triggered a spurious mid-bolus reconnect).
+ val noBolusRunning = infusion?.extendBolusInfusionInfo == null && infusion?.immeBolusInfusionInfo == null
+ val maxBolusDose = if (setting.needMaxBolusDoseSyncPatch && noBolusRunning) setting.maxBolusDose ?: 0.0 else null
+ val lowInsulinHours = if (setting.needLowInsulinNoticeAmountSyncPatch) setting.lowInsulinNoticeAmount ?: 0 else null
+ return SettingsSyncNeed(maxBolusDose, lowInsulinHours)
+ }
+
+ private fun initializeOnStart() {
+ // Run initialization directly on start instead of gating it on EventAppInitialized.
+ // onStart() is now a suspend function launched fire-and-forget, so the (non-replayed)
+ // EventAppInitialized could fire before this subscription was registered — leaving the
+ // patch uninitialized and appearing deactivated after an app update (dev fixed the same
+ // race in eopatch). initPatchOnce() does not depend on other plugins; the basal profile is
+ // applied best-effort here and, if not yet available, is set later via setNewBasalProfile().
+ pluginDisposable += carelevoPatch.initPatchOnce()
+ .subscribeOn(aapsSchedulers.io)
+ .timeout(5, TimeUnit.SECONDS)
+ .onErrorComplete()
+ .doOnSubscribe { aapsLogger.debug(LTag.PUMPCOMM, "onStart: 1) initPatchOnce waiting") }
+ .doOnComplete { aapsLogger.debug(LTag.PUMPCOMM, "onStart: 1) initPatchOnce completed") }
+ .andThen(
+ Completable.fromAction {
+ val profile = runBlocking { profileFunction.getProfile() }
+ if (profile != null) {
+ carelevoPatch.setProfile(profile)
+ aapsLogger.debug(LTag.PUMPCOMM, "onStart: 3) setProfile done: $profile")
+ } else {
+ aapsLogger.debug(LTag.PUMPCOMM, "onStart: 3) profile not ready, deferring to setNewBasalProfile")
+ }
+ }
+ )
+ .subscribe(
+ { aapsLogger.debug(LTag.PUMPCOMM, "onStart: ALL COMPLETE") },
+ { e -> aapsLogger.error(LTag.PUMPCOMM, "onStart: chain error", e) }
+ )
+
+ pluginDisposable += carelevoPatch.patchInfo
+ .observeOn(aapsSchedulers.io)
+ .subscribe({
+ _reservoirLevel.value = PumpInsulin(it.getOrNull()?.insulinRemain ?: 0.0)
+ _batteryLevel.value = 0
+ }, fabricPrivacy::logException)
+ }
+
+ private fun registerBleReceiverIfNeeded() {
+ if (bleReceiverDisposable?.isDisposed == false) return
+
+ // Seed the adapter state so isBluetoothEnabled()/patchState resolve before the first broadcast —
+ // the receiver is now the ONLY btState source (adapter on/off; there is no resting link to track).
+ carelevoPatch.onBluetoothStateChanged(currentAdapterBleState())
+
+ // The emulated patch has no radio, so the state seeded above is the whole truth. Subscribing
+ // anyway would let the host's adapter being switched off report OFF and kill a live emulated
+ // session — the one thing emulation is supposed to be immune to.
+ if (isEmulating) return
+
+ bleReceiverDisposable = CarelevoObserveReceiver(context, createBluetoothIntentFilter())
+ .subscribe { intent ->
+ aapsLogger.debug(LTag.PUMPBTCOMM, "CarelevoObserveReceiver called: ${intent.action}")
+ if (intent.action == BluetoothAdapter.ACTION_STATE_CHANGED) {
+ val value = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)
+ if (value in setOf(BluetoothAdapter.STATE_ON, BluetoothAdapter.STATE_OFF, BluetoothAdapter.STATE_TURNING_ON, BluetoothAdapter.STATE_TURNING_OFF)) {
+ carelevoPatch.onBluetoothStateChanged(adapterBleState(value.codeToDeviceResult()))
+ }
+ }
+ }
+
+ bleReceiverDisposable?.let { pluginDisposable.add(it) }
+ }
+
+ /**
+ * The emulated patch is reachable regardless of the host adapter, so report ON without asking it.
+ * Without this the whole driver — every `isBluetoothEnabled()` gate in the coordinators and view
+ * models — refuses before a request ever reaches the emulated transport. Mirrors the way Dana
+ * skips its BLE pre-check while emulating; Dana needs no equivalent here only because it never
+ * reads the adapter's enabled state at all.
+ */
+ private fun currentAdapterBleState(): BleState {
+ val enabled = isEmulating ||
+ (context.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager)?.adapter?.isEnabled == true
+ return adapterBleState(if (enabled) DeviceModuleState.DEVICE_STATE_ON else DeviceModuleState.DEVICE_STATE_OFF)
+ }
+
+ private val isEmulating: Boolean get() = config.isEnabled(ExternalOptions.EMULATE_CARELEVO)
+
+ /** Adapter-level state only — bond/discovery/notification fields are per-session now and never tracked. */
+ private fun adapterBleState(enabled: DeviceModuleState): BleState = BleState(
+ isEnabled = enabled,
+ isBonded = BondingState.BOND_NONE,
+ isServiceDiscovered = ServiceDiscoverState.DISCOVER_STATE_NONE,
+ isConnected = PeripheralConnectionState.CONN_STATE_NONE,
+ isNotificationEnabled = NotificationState.NOTIFICATION_NONE
+ )
+
+ private fun createBluetoothIntentFilter(): IntentFilter {
+ return IntentFilter().apply {
+ addAction(BluetoothAdapter.ACTION_STATE_CHANGED)
+ }
+ }
+
+ private fun applyDefaultCageThresholdsIfNeeded() {
+ if (sp.getBoolean(CarelevoBooleanPreferenceKey.CARELEVO_CAGE_DEFAULT_APPLIED.key, false)) return
+
+ sp.edit {
+ putInt(IntKey.OverviewCageWarning.key, 96)
+ putInt(IntKey.OverviewCageCritical.key, 168)
+ putBoolean(CarelevoBooleanPreferenceKey.CARELEVO_CAGE_DEFAULT_APPLIED.key, true)
+ }
+ }
+
+ private suspend fun startAlarmObserving() {
+ aapsLogger.debug(LTag.NOTIFICATION, "startAlarmObserving:: onStart")
+
+ val observer = LifecycleEventObserver { _, event ->
+ if (event == Lifecycle.Event.ON_START) {
+ aapsLogger.debug(LTag.NOTIFICATION, "Foreground transition -> refresh alarms")
+ carelevoAlarmNotifier.refreshAlarms()
+ }
+ }
+ lifecycleObserver = observer
+ withContext(Dispatchers.Main) {
+ ProcessLifecycleOwner.get().lifecycle.addObserver(observer)
+ }
+
+ carelevoAlarmNotifier.startObserving { alarms ->
+ aapsLogger.debug(LTag.NOTIFICATION, "observe alarms size=${alarms.size}, $alarms")
+ handleAlarms(alarms)
+ }
+ }
+
+ // Critical alarms already escalated to the global alarm (so a re-emission of the same list
+ // doesn't re-fire the sound). Pruned to the currently-active set on every pass.
+ private val globallyAlarmedIds = mutableSetOf()
+
+ private fun handleAlarms(alarms: List) {
+ aapsLogger.debug(LTag.NOTIFICATION, "startAlarmObserving handleAlarms:: $alarms")
+ globallyAlarmedIds.retainAll(alarms.map { it.alarmId }.toSet())
+ if (alarms.isEmpty()) return
+
+ val critical = alarms.filter { it.alarmType.isCritical() }
+ if (critical.isNotEmpty()) {
+ // filter-with-add: keeps only the not-yet-escalated alarms AND marks them escalated.
+ val fresh = critical.filter { globallyAlarmedIds.add(it.alarmId) }
+ if (carelevoAlarmNotifier.alarmHostActive) {
+ // The in-app host is mounted — it presents the full-screen alarm and starts the
+ // sound itself (CarelevoAlarmHost/CarelevoAlarmViewModel).
+ aapsLogger.debug(LTag.NOTIFICATION, "critical alarm handled by compose host")
+ } else if (fresh.isNotEmpty()) {
+ // No in-app surface (backgrounded, or user on another screen): fire the global AAPS
+ // alarm (sound + full-screen intent) — a critical patch alarm must NEVER depend on
+ // the user having the Carelevo screen open.
+ val first = fresh.first()
+ uiInteraction.runAlarm(
+ status = rh.gs(first.cause.transformNotificationStringResources().first),
+ title = rh.gs(R.string.carelevo),
+ soundId = CoreUiR.raw.error
+ )
+ }
+ } else {
+ carelevoAlarmNotifier.showTopNotification(alarms)
+ }
+ }
+
+ override fun getPreferenceScreenContent() = PreferenceSubScreenDef(
+ key = "carelevo_settings",
+ titleResId = R.string.carelevo,
+ items = listOf(
+ CarelevoIntPreferenceKey.CARELEVO_LOW_INSULIN_EXPIRATION_REMINDER_HOURS.withEntries(
+ (20..50 step 5).associateWith { "$it U" }
+ ),
+ CarelevoIntPreferenceKey.CARELEVO_PATCH_EXPIRATION_REMINDER_HOURS.withEntries(
+ (24..167 step 1).associateWith { "$it ${rh.gs(app.aaps.core.interfaces.R.string.hours)}" }
+ ),
+ CarelevoBooleanPreferenceKey.CARELEVO_BUZZER_REMINDER
+ ),
+ icon = pluginDescription.icon
+ )
+
+ // A patch is "configured" once activation has persisted a patch record (patchInfo present) — the
+ // same signal isInitialized() gates on first, so isInitialized() implies isConfigured() and the
+ // contract invariant !isConfigured() => !isInitialized() holds by construction. Intentionally
+ // independent of BLE: an attached-but-disconnected patch is still configured and may be delivering.
+ override fun isConfigured(): Boolean =
+ carelevoPatch.patchInfo.value?.getOrNull() != null
+
+ override fun isInitialized(): Boolean {
+ return connectionCoordinator.isInitialized()
+ }
+
+ override fun isSuspended(): Boolean {
+ // Real delivery-suspend (pump stopped by the user), NOT the BLE connection state. Otherwise, a
+ // normal idle disconnect (NotConnectedBooted, now that disconnect() actually disconnects) would
+ // be reported as suspended and surface as an error/suspended icon on the overview.
+ return carelevoPatch.patchInfo.value?.getOrNull()?.isStopped ?: false
+ }
+
+ override fun isBusy(): Boolean {
+ return false
+ }
+
+ override fun isConnected(): Boolean {
+ return connectionCoordinator.isConnected()
+ }
+
+ override fun isConnecting(): Boolean {
+ return connectionCoordinator.isConnecting()
+ }
+
+ override fun isHandshakeInProgress(): Boolean {
+ return false
+ }
+
+ override fun connect(reason: String) {
+ connectionCoordinator.connect(reason)
+ }
+
+ override fun disconnect(reason: String) {
+ connectionCoordinator.disconnect(reason)
+ }
+
+ override fun stopConnecting() {
+ connectionCoordinator.stopConnecting()
+ }
+
+ override suspend fun getPumpStatus(reason: String) = readInfusionInfo()
+
+ /**
+ * Status read over the [app.aaps.pump.carelevo.ble.BleClient] stack: read Infusion Info (0x31 → 0x91)
+ * on the session's own connection and persist it through `carelevoPatch.applyInfusionInfoReport` —
+ * reservoir/pump-state/totals all refresh. Runs on
+ * the QueueWorker thread, blocked inside this status read.
+ */
+ private suspend fun readInfusionInfo() {
+ val address = carelevoPatch.getPatchInfoAddress() ?: run {
+ aapsLogger.warn(LTag.PUMPCOMM, "newBle.readInfusionInfo skipped: no patch address")
+ return
+ }
+ try {
+ val info = bleSession.readInfusionInfo(address)
+ carelevoPatch.applyInfusionInfoReport(
+ runningMinutes = info.runningMinutes,
+ remains = info.insulinRemaining,
+ infusedTotalBasalAmount = info.infusedTotalBasalAmount,
+ infusedTotalBolusAmount = info.infusedTotalBolusAmount,
+ pumpStateRaw = info.pumpStateRaw,
+ modeRaw = info.modeRaw
+ )
+ _lastDataTime.value = System.currentTimeMillis()
+ aapsLogger.info(
+ LTag.PUMPCOMM,
+ "newBle.readInfusionInfo OK remains=${info.insulinRemaining} basal=${info.infusedTotalBasalAmount} " +
+ "bolus=${info.infusedTotalBolusAmount} pumpState=${info.pumpStateRaw} mode=${info.modeRaw} running=${info.runningMinutes}"
+ )
+ } catch (e: Throwable) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.readInfusionInfo FAILED", e)
+ }
+ }
+
+ override suspend fun setNewBasalProfile(profile: PumpProfile): PumpEnactResult {
+ aapsLogger.debug(LTag.PUMP, "setNewBasalProfile called - ${carelevoPatch.resolvePatchState()}")
+ _lastDataTime.value = System.currentTimeMillis()
+ // PROFILE_SET_OK / FAILED_UPDATE_PROFILE are posted centrally by the CommandQueue from the returned
+ // success/enacted (unified across pumps) — this method only returns the right values.
+ val result = when (carelevoPatch.resolvePatchState()) {
+ is PatchState.NotConnectedNotBooting -> {
+ // No active patch yet — store the profile for when a patch is activated. A deferred write,
+ // not an actual change, so enacted=false (no PROFILE_SET_OK); success=true keeps the
+ // not-ready case out of the failure alarm (matches the other queue-managed pumps).
+ carelevoPatch.setProfile(profile)
+ pumpEnactResultProvider.get().success(true).enacted(false)
+ }
+
+ else -> {
+ // Patch present. setNewBasalProfile runs on the queue worker AFTER the queue guaranteed a
+ // fully-connected link, so this is the live push path even if the cached patchState briefly
+ // reads NotConnectedBooted. updateBasalProfile returns the real success/enacted result.
+ updateBasalProfile(profile)
+ }
+ }
+ aapsLogger.debug(LTag.PUMP, "result success=${result.success} enacted=${result.enacted} comment=${result.comment}")
+ return result
+ }
+
+ private fun updateBasalProfile(profile: Profile): PumpEnactResult {
+ return basalProfileUpdateCoordinator.updateBasalProfile(
+ profile = profile,
+ cancelExtendedBolus = {
+ bolusCoordinator.cancelExtendedBolus(
+ serialNumber = serialNumber(),
+ onLastDataUpdated = { _lastDataTime.value = System.currentTimeMillis() }
+ )
+ },
+ cancelTempBasal = {
+ tempBasalCoordinator.cancelTempBasal(
+ serialNumber = serialNumber(),
+ onLastDataUpdated = { _lastDataTime.value = System.currentTimeMillis() }
+ )
+ },
+ onProfileUpdated = { updatedProfile ->
+ _lastDataTime.value = System.currentTimeMillis()
+ carelevoPatch.setProfile(updatedProfile)
+ }
+ )
+ }
+
+ override fun isThisProfileSet(profile: PumpProfile): Boolean {
+ return carelevoPatch.checkIsSameProfile(profile)
+ }
+
+ // Activation ops (safety check, …) are queued so they get the CommandQueue's managed
+ // connect-before-execute / reconnect lifecycle instead of a direct BLE call.
+ override fun executeCustomCommand(customCommand: CustomCommand): PumpEnactResult? =
+ activationExecutor.execute(customCommand)
+
+ private val _lastDataTime = MutableStateFlow(0L)
+ override val lastDataTime: StateFlow = _lastDataTime.asStateFlow()
+
+ override val lastBolusTime: StateFlow
+ get() = bolusCoordinator.lastBolusTime
+
+ override val lastBolusAmount: StateFlow
+ get() = bolusCoordinator.lastBolusAmount
+
+ override val baseBasalRate: PumpRate
+ get() = PumpRate(carelevoPatch.profile.value?.getOrNull()?.getBasal() ?: 0.0)
+
+ private val _reservoirLevel = MutableStateFlow(PumpInsulin(0.0))
+ override val reservoirLevel: StateFlow = _reservoirLevel
+
+ private val _batteryLevel = MutableStateFlow(null)
+ override val batteryLevel: StateFlow = _batteryLevel
+
+ // start imme bolus infusion
+ override suspend fun deliverTreatment(detailedBolusInfo: DetailedBolusInfo): PumpEnactResult {
+ return bolusCoordinator.deliverTreatment(
+ detailedBolusInfo = detailedBolusInfo,
+ serialNumber = serialNumber(),
+ onLastDataUpdated = { _lastDataTime.value = System.currentTimeMillis() },
+ pluginDisposable = pluginDisposable
+ )
+ }
+
+ // cancel imme bolus
+ override fun stopBolusDelivering() {
+ bolusCoordinator.cancelImmediateBolus(
+ serialNumber = serialNumber(),
+ onLastDataUpdated = { _lastDataTime.value = System.currentTimeMillis() }
+ )
+ }
+
+ // enforceNew is intentionally ignored on all three TBR entry points: with per-op sessions there
+ // is no resting link whose state a "keep the running TBR" optimization could trust, so Carelevo
+ // always re-programs the requested TBR (the Pump contract explicitly allows this; the flag is
+ // only an optimization hint).
+ override suspend fun setTempBasalAbsolute(absoluteRate: Double, durationInMinutes: Int, enforceNew: Boolean, tbrType: PumpSync.TemporaryBasalType): PumpEnactResult {
+ return tempBasalCoordinator.setTempBasalAbsolute(
+ absoluteRate = absoluteRate,
+ durationInMinutes = durationInMinutes,
+ tbrType = tbrType,
+ serialNumber = serialNumber(),
+ onLastDataUpdated = { _lastDataTime.value = System.currentTimeMillis() }
+ )
+ }
+
+ override suspend fun setTempBasalPercent(percent: Int, durationInMinutes: Int, enforceNew: Boolean, tbrType: PumpSync.TemporaryBasalType): PumpEnactResult {
+ return tempBasalCoordinator.setTempBasalPercent(
+ percent = percent,
+ durationInMinutes = durationInMinutes,
+ tbrType = tbrType,
+ serialNumber = serialNumber(),
+ onLastDataUpdated = { _lastDataTime.value = System.currentTimeMillis() }
+ )
+ }
+
+ override suspend fun cancelTempBasal(enforceNew: Boolean): PumpEnactResult {
+ return tempBasalCoordinator.cancelTempBasal(
+ serialNumber = serialNumber(),
+ onLastDataUpdated = { _lastDataTime.value = System.currentTimeMillis() }
+ )
+ }
+
+ override suspend fun setExtendedBolus(insulin: Double, durationInMinutes: Int): PumpEnactResult {
+ return bolusCoordinator.setExtendedBolus(
+ insulin = insulin,
+ durationInMinutes = durationInMinutes,
+ serialNumber = serialNumber()
+ )
+ }
+
+ override suspend fun cancelExtendedBolus(): PumpEnactResult {
+ return bolusCoordinator.cancelExtendedBolus(
+ serialNumber = serialNumber(),
+ onLastDataUpdated = { _lastDataTime.value = System.currentTimeMillis() }
+ )
+ }
+
+ override fun manufacturer(): ManufacturerType {
+ return ManufacturerType.CareMedi
+ }
+
+ override fun model(): PumpType {
+ return PumpType.CAREMEDI_CARELEVO
+ }
+
+ override fun serialNumber(): String {
+ return carelevoPatch.patchInfo.value?.getOrNull()?.manufactureNumber ?: ""
+ }
+
+ override val pumpDescription: PumpDescription
+ get() = _pumpDescription
+
+ override val isFakingTempsByExtendedBoluses: Boolean
+ get() = false
+
+ override suspend fun loadTDDs(): PumpEnactResult {
+ return pumpEnactResultProvider.get()
+ }
+
+ override fun canHandleDST(): Boolean {
+ return false
+ }
+
+ override suspend fun timezoneOrDSTChanged(timeChangeType: TimeChangeType) {
+ super.timezoneOrDSTChanged(timeChangeType)
+ // Route through the queue (connect-before-execute) like every other patch op. The pump
+ // idle-disconnects between commands, so a direct fire-and-forget write would silently fail
+ // while resting. Skip ONLY when no patch is active; if the patch is present but its insulinRemain
+ // is not yet known (e.g. before the first status read after reconnect) still push with 0 rather
+ // than dropping the clock update (original `?: 0` semantics).
+ val patchInfo = carelevoPatch.patchInfo.value?.getOrNull() ?: return
+ val insulin = patchInfo.insulinRemain?.toInt() ?: 0
+ val result = commandQueue.customCommand(CmdTimeZoneUpdate(insulinAmount = insulin))
+ if (result.success) _lastDataTime.value = System.currentTimeMillis()
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/BleClient.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/BleClient.kt
new file mode 100644
index 000000000000..733759b1f7f7
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/BleClient.kt
@@ -0,0 +1,182 @@
+package app.aaps.pump.carelevo.ble
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.SharedFlow
+
+/**
+ * Request/response client over a [app.aaps.pump.carelevo.ble.gatt.GattConnection].
+ *
+ * Serializes outgoing writes with a mutex so at most one request is in flight at any
+ * moment, and correlates each request with the peripheral's notification by opcode
+ * pair (and, for the immediate-bolus command, by echoed actionId).
+ *
+ * Notifications arriving outside any active request are forwarded to
+ * [unsolicitedEvents] so alarm/status-report consumers can subscribe independently.
+ */
+interface BleClient {
+
+ /**
+ * Send [cmd], suspend until the matching response notification arrives, then
+ * return the decoded response.
+ *
+ * Does **not** impose a timeout — callers wrap in `withTimeout(...)` if a
+ * deadline is wanted. Different pump operations have legitimately different
+ * deadlines (e.g. safety-check is ~100 s, most requests are ~3 s), so the
+ * policy lives at the caller.
+ *
+ * Throws:
+ * - [BleDisconnectedException] if the GATT connection drops while the request
+ * is pending.
+ * - [app.aaps.pump.carelevo.ble.gatt.GattWriteException] if the BLE write fails.
+ * - [kotlinx.coroutines.CancellationException] on coroutine cancellation
+ * (including `withTimeout`).
+ */
+ suspend fun request(cmd: BleCommand): R
+
+ /**
+ * Send [cmd], suspend until **all** of its [BleMultiCommand.expectedResponseOpcodes]
+ * have arrived (in any order), then decode them together.
+ *
+ * For requests the pump answers with more than one notification — e.g. Patch
+ * Information Inquiry (`0x33`), answered by RPT1 (`0x93`) + RPT2 (`0x94`). The first
+ * notification seen for each expected opcode wins; a duplicate or any non-matching
+ * notification (alarm, status push) falls through to [unsolicitedEvents].
+ *
+ * Same deadline policy as [request] — no built-in timeout, wrap in `withTimeout(...)`.
+ * A single deadline wraps the whole call (not per-response).
+ *
+ * Throws [BleDisconnectedException] / [app.aaps.pump.carelevo.ble.gatt.GattWriteException] /
+ * [kotlinx.coroutines.CancellationException] on the same conditions as [request].
+ */
+ suspend fun requestMultiple(cmd: BleMultiCommand): R
+
+ /**
+ * Send [cmd] and return a cold [Flow] of every decoded notification matching
+ * [BleStreamCommand.expectedResponseOpcode], completing when [BleStreamCommand.isTerminal]
+ * is `true` for a decoded response.
+ *
+ * For streaming/progress requests — e.g. Safety Check (`0x12`): the pump emits
+ * repeated progress reports then a terminal SUCCESS/error, all on `0x72`. The
+ * request write happens when the returned flow is collected; the request slot is
+ * held for the whole stream (single-in-flight), so a concurrent [request] waits
+ * until the stream terminates.
+ *
+ * The flow throws [BleDisconnectedException] if the link drops mid-stream. As with
+ * [request], impose a deadline by wrapping collection in `withTimeout(...)`.
+ *
+ * **Do not call any [BleClient] method from inside this flow's collector.** The
+ * request slot (a non-reentrant mutex) is held for the whole stream, so a reentrant
+ * `request`/`requestMultiple`/`requestStream` issued from the `collect {}` block
+ * self-deadlocks. Collect the stream to completion first, then issue the next
+ * request outside the collector.
+ */
+ fun requestStream(cmd: BleStreamCommand): Flow
+
+ /**
+ * Hot stream of notifications that did not match any active request — alarms,
+ * status pushes, cannula-insertion events, etc. Subscribers see only events
+ * emitted after they subscribe (no replay). Independent from [request] —
+ * alarm handling and request/response correlation do not interfere.
+ */
+ val unsolicitedEvents: SharedFlow
+}
+
+/**
+ * A single CareLevo protocol request, paired with the Kotlin type of its expected
+ * response. Implementations encode the outgoing byte-array, declare the opcode
+ * pair, and decode the response bytes back into a typed model.
+ */
+interface BleCommand {
+
+ /** Opcode byte (position 0) of the outgoing write. */
+ val requestOpcode: Byte
+
+ /** Opcode byte (position 0) that the peripheral is expected to reply with. */
+ val expectedResponseOpcode: Byte
+
+ /**
+ * Optional correlation byte at position 1 of the response. Non-null for commands
+ * that echo a caller-chosen identifier (e.g. immediate bolus `actionId`). When
+ * non-null, [BleClient] only accepts responses whose byte-1 equals this value —
+ * belt-and-braces against a stale or unsolicited message with the same opcode.
+ */
+ val correlationByte: Byte? get() = null
+
+ /** Full outgoing payload, starting with [requestOpcode] at byte 0. */
+ fun encode(): ByteArray
+
+ /** Parse the full response payload (byte 0 is [expectedResponseOpcode]). */
+ fun decode(responsePayload: ByteArray): R
+}
+
+/**
+ * A CareLevo request that a single write answers with **more than one** notification —
+ * e.g. Patch Information Inquiry (`0x33`) → RPT1 (`0x93`) + RPT2 (`0x94`).
+ *
+ * [BleClient.requestMultiple] collects the first notification seen for each opcode in
+ * [expectedResponseOpcodes] (arrival order irrelevant) and completes once every opcode
+ * in the set has been received, then hands the collected payloads to [decode].
+ */
+interface BleMultiCommand {
+
+ /** Opcode byte (position 0) of the outgoing write. */
+ val requestOpcode: Byte
+
+ /**
+ * The full set of response opcodes this request produces. The request completes
+ * only once one notification for **each** opcode has arrived. Must be non-empty.
+ */
+ val expectedResponseOpcodes: Set
+
+ /** Full outgoing payload, starting with [requestOpcode] at byte 0. */
+ fun encode(): ByteArray
+
+ /**
+ * Parse the collected responses, keyed by their opcode (byte 0 of each payload).
+ * Every key in [expectedResponseOpcodes] is guaranteed present.
+ */
+ fun decode(responses: Map): R
+}
+
+/**
+ * A CareLevo request whose response is a **stream** — repeated notifications on one
+ * opcode, terminated by a distinguished response. E.g. Safety Check (`0x12`): the pump
+ * emits progress reports (`REP_REQUEST`) then a terminal SUCCESS/error, all on `0x72`.
+ *
+ * [BleClient.requestStream] decodes each notification matching [expectedResponseOpcode]
+ * and emits it; the stream completes when [isTerminal] returns `true` for a decoded
+ * response. Non-matching notifications fall through to [BleClient.unsolicitedEvents].
+ */
+interface BleStreamCommand {
+
+ /** Opcode byte (position 0) of the outgoing write. */
+ val requestOpcode: Byte
+
+ /** Opcode byte (position 0) each streamed response notification carries. */
+ val expectedResponseOpcode: Byte
+
+ /** Full outgoing payload, starting with [requestOpcode] at byte 0. */
+ fun encode(): ByteArray
+
+ /** Parse one streamed response payload (byte 0 is [expectedResponseOpcode]). */
+ fun decode(responsePayload: ByteArray): R
+
+ /** `true` when [response] is the final one — the stream completes after emitting it. */
+ fun isTerminal(response: R): Boolean
+}
+
+/** Marker type for decoded CareLevo responses. */
+interface BleResponse
+
+/**
+ * A notification that did not match any active request — an alarm, status report,
+ * or other peripheral-initiated push. Carries the raw payload; higher layers parse
+ * it via the existing parser registry.
+ */
+data class UnsolicitedMessage(
+ val opcode: Byte,
+ val payload: ByteArray
+)
+
+/** Thrown by a pending [BleClient.request] if the GATT connection drops. */
+class BleDisconnectedException(message: String = "connection dropped") : RuntimeException(message)
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/BleClientImpl.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/BleClientImpl.kt
new file mode 100644
index 000000000000..33d2e6c766fb
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/BleClientImpl.kt
@@ -0,0 +1,320 @@
+package app.aaps.pump.carelevo.ble
+
+import app.aaps.pump.carelevo.ble.gatt.GattConnState
+import app.aaps.pump.carelevo.ble.gatt.GattConnection
+import app.aaps.pump.carelevo.ble.gatt.GattEvent
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.util.UUID
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * Production implementation of [BleClient].
+ *
+ * Correlation rules (see [BleClientContractTest] in tests for the full spec):
+ * - A single [requestMutex] serializes outgoing requests — at most one in flight,
+ * whether single-response, multi-response, or streaming.
+ * - Before calling [GattConnection.writeCharacteristic], the client registers a
+ * [Waiter] describing the response(s) it expects. This ordering eliminates the
+ * response-during-write race.
+ * - A long-lived collector on the injected [scope] reads [GattConnection.events] and
+ * offers each [GattEvent.Notification] to the active [Waiter]; anything the waiter
+ * does not consume is forwarded to [_unsolicitedEvents].
+ * - A [GattEvent.ConnectionStateChanged] with [GattConnState.DISCONNECTED] aborts the
+ * pending waiter (with [BleDisconnectedException]) atomically.
+ *
+ * The event collector is the single point through which every request completes, so it
+ * is hardened to survive any callback failure: the [waiter] is held in an
+ * [AtomicReference] (so a disconnect can atomically take-and-abort whatever request is
+ * current without clobbering a concurrently-registered one), consumer-supplied
+ * [BleStreamCommand.decode]/[BleStreamCommand.isTerminal] are guarded, and the collect
+ * body is wrapped so no unforeseen throw can permanently stop routing.
+ */
+class BleClientImpl(
+ private val gatt: GattConnection,
+ private val writeUuid: UUID,
+ @Suppress("unused")
+ private val notifyUuid: UUID,
+ scope: CoroutineScope
+) : BleClient {
+
+ // DROP_OLDEST + tryEmit: unsolicited fan-out (alarms/status are lossy pushes) can
+ // never back-pressure the event collector and stall in-flight request correlation.
+ private val _unsolicitedEvents = MutableSharedFlow(
+ extraBufferCapacity = 64,
+ onBufferOverflow = BufferOverflow.DROP_OLDEST
+ )
+ override val unsolicitedEvents: SharedFlow = _unsolicitedEvents.asSharedFlow()
+
+ private val requestMutex = Mutex()
+
+ /**
+ * The response(s) the in-flight request is waiting for. Exactly one is active at a
+ * time (guarded by [requestMutex] on the caller side). Held in an [AtomicReference]
+ * because the event collector aborts it on disconnect **outside** the mutex (a
+ * stream holds the mutex for its whole 100-210 s duration, so the collector must
+ * stay lock-free): [AtomicReference.getAndSet] takes-and-nulls atomically so a
+ * disconnect can never null a freshly-registered waiter without also aborting it.
+ */
+ private val waiterRef = AtomicReference(null)
+
+ private sealed interface Waiter {
+
+ /** Try to consume the notification [payload] (opcode is [opcode]). Return `true` iff consumed. */
+ fun offer(opcode: Byte, payload: ByteArray): Boolean
+
+ /** Abort this pending request (link dropped, or an unforeseen router failure). */
+ fun abort(cause: Throwable)
+
+ /**
+ * Called by the requesting coroutine when it unwinds WITHOUT having consumed the
+ * response (cancellation/timeout). After this returns, [offer] consumes nothing
+ * more, so late frames fall through to [unsolicitedEvents]. Returns any frame(s)
+ * this waiter had already absorbed but never delivered to the caller, so the
+ * caller can re-route them to unsolicited instead of silently swallowing a
+ * response the pump really sent (e.g. the ack of a bolus that DID start while
+ * our side timed out).
+ */
+ fun abandon(): List
+ }
+
+ private class SingleWaiter(
+ private val expectedOpcode: Byte,
+ private val correlationByte: Byte?,
+ private val deferred: CompletableDeferred
+ ) : Waiter {
+
+ override fun offer(opcode: Byte, payload: ByteArray): Boolean {
+ if (opcode != expectedOpcode) return false
+ val correlationOk = correlationByte == null ||
+ (payload.size > 1 && payload[1] == correlationByte)
+ if (!correlationOk) return false
+ // complete() returns false if already settled — a late duplicate (already
+ // completed) or an abandoned caller (deferred cancelled by abandon()) — so
+ // routeNotification forwards the frame to unsolicited either way.
+ return deferred.complete(payload)
+ }
+
+ override fun abort(cause: Throwable) {
+ deferred.completeExceptionally(cause)
+ }
+
+ @OptIn(ExperimentalCoroutinesApi::class)
+ override fun abandon(): List {
+ // cancel() races atomically against offer()'s complete(): exactly one wins.
+ // If cancel wins, a concurrent/late offer returns false and the frame is
+ // routed to unsolicited by the collector. If complete already won, the
+ // payload sits in a deferred nobody will await — hand it back for re-routing.
+ deferred.cancel()
+ return if (deferred.isCompleted && !deferred.isCancelled) listOf(deferred.getCompleted()) else emptyList()
+ }
+ }
+
+ private class MultiWaiter(
+ private val remaining: MutableSet,
+ private val deferred: CompletableDeferred>
+ ) : Waiter {
+
+ private val collected = mutableMapOf()
+
+ override fun offer(opcode: Byte, payload: ByteArray): Boolean {
+ // Abandoned by the caller — stop consuming so frames route to unsolicited.
+ // (offer runs only on the single collector coroutine; isCancelled is the
+ // cross-thread signal from abandon(). A frame absorbed into `collected` in
+ // the narrow window before cancel lands is dropped with its partial map —
+ // a partial multi-response is unusable anyway and pairing redoes the round.)
+ if (deferred.isCancelled) return false
+ // First notification per expected opcode wins; a duplicate opcode is no
+ // longer in `remaining`, so it falls through to unsolicited.
+ if (!remaining.remove(opcode)) return false
+ collected[opcode] = payload
+ if (remaining.isEmpty() && !deferred.complete(collected.toMap())) return false
+ return true
+ }
+
+ override fun abort(cause: Throwable) {
+ deferred.completeExceptionally(cause)
+ }
+
+ @OptIn(ExperimentalCoroutinesApi::class)
+ override fun abandon(): List {
+ deferred.cancel()
+ return if (deferred.isCompleted && !deferred.isCancelled) deferred.getCompleted().values.toList() else emptyList()
+ }
+ }
+
+ private class StreamWaiter(
+ private val expectedOpcode: Byte,
+ private val decode: (ByteArray) -> R,
+ private val isTerminal: (R) -> Boolean,
+ private val channel: Channel
+ ) : Waiter {
+
+ override fun offer(opcode: Byte, payload: ByteArray): Boolean {
+ if (opcode != expectedOpcode) return false
+ // Both consumer-supplied callbacks run here on the shared event collector,
+ // so both are guarded: a throw must end THIS stream, never escape onto the
+ // collector and brick routing for every future request.
+ val decoded = try {
+ decode(payload)
+ } catch (t: Throwable) {
+ channel.close(t)
+ return true
+ }
+ // Channel is UNLIMITED, so a success means it was accepted; a failure means
+ // it is already closed (terminal already delivered) — treat a late same-opcode
+ // frame as not-consumed so it falls through to unsolicited.
+ if (!channel.trySend(decoded).isSuccess) return false
+ val terminal = try {
+ isTerminal(decoded)
+ } catch (t: Throwable) {
+ channel.close(t)
+ return true
+ }
+ if (terminal) channel.close()
+ return true
+ }
+
+ override fun abort(cause: Throwable) {
+ channel.close(cause)
+ }
+
+ override fun abandon(): List {
+ // cancel() (not close()) so a concurrent trySend fails and the frame routes
+ // to unsolicited. Frames already decoded into the channel are typed R, not
+ // raw bytes — nothing to re-route; stream frames are progress reports whose
+ // loss the stream consumer already treats as a failed operation.
+ channel.cancel()
+ return emptyList()
+ }
+ }
+
+ init {
+ scope.launch {
+ gatt.events.collect { evt ->
+ try {
+ onEvent(evt)
+ } catch (t: CancellationException) {
+ throw t
+ } catch (t: Throwable) {
+ // The sole event router must never die. Callback throws are already
+ // guarded above; this is a last-resort backstop — abort the active
+ // request so its caller fails fast rather than hanging on a response
+ // that will never route, and keep the collector alive.
+ waiterRef.getAndSet(null)?.abort(t)
+ }
+ }
+ }
+ }
+
+ private fun onEvent(evt: GattEvent) {
+ when (evt) {
+ is GattEvent.Notification -> routeNotification(evt.payload)
+
+ is GattEvent.ConnectionStateChanged -> {
+ if (evt.state == GattConnState.DISCONNECTED) {
+ // Atomically take-and-null so a late-arriving notification falls
+ // through to unsolicited rather than hitting an aborted waiter.
+ waiterRef.getAndSet(null)?.abort(BleDisconnectedException())
+ }
+ }
+
+ is GattEvent.ServicesDiscovered,
+ is GattEvent.WriteAck -> Unit
+ }
+ }
+
+ private fun routeNotification(payload: ByteArray) {
+ if (payload.isEmpty()) return
+ val opcode = payload[0]
+ if (waiterRef.get()?.offer(opcode, payload) == true) return
+ // tryEmit never suspends (DROP_OLDEST) so the collector can't be back-pressured.
+ _unsolicitedEvents.tryEmit(UnsolicitedMessage(opcode, payload))
+ }
+
+ /**
+ * Tears down [waiter] after its requesting coroutine unwound without consuming the
+ * response (cancellation/timeout), re-routing any frame the waiter had already
+ * absorbed to [unsolicitedEvents] — see [Waiter.abandon].
+ */
+ private fun abandonAndReroute(waiter: Waiter) {
+ for (frame in waiter.abandon()) {
+ if (frame.isNotEmpty()) _unsolicitedEvents.tryEmit(UnsolicitedMessage(frame[0], frame))
+ }
+ }
+
+ override suspend fun request(cmd: BleCommand): R = requestMutex.withLock {
+ val deferred = CompletableDeferred()
+ // Register the waiter BEFORE writing so a synchronous response from the
+ // peripheral cannot race ahead of our subscription.
+ val waiter = SingleWaiter(cmd.expectedResponseOpcode, cmd.correlationByte, deferred)
+ waiterRef.set(waiter)
+ var consumed = false
+ try {
+ gatt.writeCharacteristic(writeUuid, cmd.encode())
+ val payload = deferred.await()
+ consumed = true
+ cmd.decode(payload)
+ } finally {
+ // compareAndSet: never clobber a successor registered after a disconnect
+ // already took-and-aborted this waiter.
+ waiterRef.compareAndSet(waiter, null)
+ if (!consumed) abandonAndReroute(waiter)
+ }
+ }
+
+ override suspend fun requestMultiple(cmd: BleMultiCommand): R =
+ requestMutex.withLock {
+ require(cmd.expectedResponseOpcodes.isNotEmpty()) {
+ "expectedResponseOpcodes must not be empty"
+ }
+ val deferred = CompletableDeferred>()
+ val waiter = MultiWaiter(cmd.expectedResponseOpcodes.toMutableSet(), deferred)
+ waiterRef.set(waiter)
+ var consumed = false
+ try {
+ gatt.writeCharacteristic(writeUuid, cmd.encode())
+ val responses = deferred.await()
+ consumed = true
+ cmd.decode(responses)
+ } finally {
+ waiterRef.compareAndSet(waiter, null)
+ if (!consumed) abandonAndReroute(waiter)
+ }
+ }
+
+ override fun requestStream(cmd: BleStreamCommand): Flow = flow {
+ requestMutex.withLock {
+ val channel = Channel(Channel.UNLIMITED)
+ // Register BEFORE writing (same race-free ordering as request()).
+ val waiter = StreamWaiter(cmd.expectedResponseOpcode, cmd::decode, cmd::isTerminal, channel)
+ waiterRef.set(waiter)
+ try {
+ gatt.writeCharacteristic(writeUuid, cmd.encode())
+ // Emits every decoded notification; the channel is closed by the
+ // StreamWaiter on the terminal response, on decode/isTerminal failure
+ // (rethrown here as the close cause), or on disconnect.
+ for (item in channel) {
+ emit(item)
+ }
+ } finally {
+ waiterRef.compareAndSet(waiter, null)
+ // Always abandon: a no-op after normal completion (channel already
+ // closed), and after cancellation it flips late frames to unsolicited.
+ waiter.abandon()
+ }
+ }
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/CarelevoBleSession.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/CarelevoBleSession.kt
new file mode 100644
index 000000000000..b1974b22d015
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/CarelevoBleSession.kt
@@ -0,0 +1,510 @@
+package app.aaps.pump.carelevo.ble
+
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.pump.carelevo.ble.commands.AlertAlarmSetCommand
+import app.aaps.pump.carelevo.ble.commands.AppAuthCommand
+import app.aaps.pump.carelevo.ble.commands.BasalProgramCommand
+import app.aaps.pump.carelevo.ble.commands.InfusionInfoCommand
+import app.aaps.pump.carelevo.ble.commands.InfusionInfoResponse
+import app.aaps.pump.carelevo.ble.commands.MacAddressCommand
+import app.aaps.pump.carelevo.ble.commands.PatchInfoResponse
+import app.aaps.pump.carelevo.ble.commands.SafetyCheckCommand
+import app.aaps.pump.carelevo.ble.commands.SafetyCheckResponse
+import app.aaps.pump.carelevo.ble.commands.SetTimeForPatchInfoCommand
+import app.aaps.pump.carelevo.ble.commands.ThresholdSetupCommand
+import app.aaps.pump.carelevo.ble.gatt.BleTransportGattConnection
+import app.aaps.pump.carelevo.ble.gatt.GattConnState
+import app.aaps.pump.carelevo.ble.gatt.GattEvent
+import app.aaps.pump.carelevo.ext.checkSumV2
+import app.aaps.pump.carelevo.ext.convertHexToByteArray
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.withTimeoutOrNull
+import org.joda.time.DateTime
+import java.util.UUID
+import javax.inject.Inject
+import javax.inject.Named
+import javax.inject.Singleton
+import kotlin.time.Duration.Companion.milliseconds
+
+/**
+ * Owns BLE sessions: connect → discover services → enable notifications → run [BleClient] exchanges → close.
+ *
+ * Two modes share one code path ([withSession]):
+ * - **Queue-owned held link** ([openLink]/[requestConnect] … [requestDisconnect]): the AAPS CommandQueue
+ * holds ONE session open across a whole connect→run-ops→disconnect burst; every op reuses it, so a
+ * multi-op sequence (e.g. cancel-temp then pump-stop) does NOT re-dial between ops. This is the resting
+ * therapy path once a patch is activated. See `_docs/CARELEVO_QUEUE_OWNED_LINK.md`.
+ * - **Transient per-op session** ([transientSession]): open→run→close for pre-activation / pairing / any op
+ * with no held link.
+ *
+ * Either way each session builds a **fresh** [BleTransportGattConnection] + [BleClientImpl] + [CoroutineScope]
+ * and closes them once: [BleTransportGattConnection.close] is one-shot (it latches `closed` and releases the
+ * transport's single listener slot), so a closed instance is never reused — [openLink] builds a new one on
+ * every connect, and [tearDownHeld]/[transientSession] close it exactly once.
+ *
+ * A session opens its own GATT; two GATT clients to one patch cause the status-133 collision, so a
+ * session must not run concurrently with any other link to the patch. The caller (a customCommand)
+ * is responsible for ensuring no other link is active before invoking a session.
+ */
+@Singleton
+class CarelevoBleSession @Inject constructor(
+ private val transport: CarelevoBleTransport,
+ @Named("characterRx") private val writeUuid: UUID,
+ @Named("characterTx") private val notifyUuid: UUID,
+ private val aapsLogger: AAPSLogger
+) {
+
+ // The new transport is a @Singleton with a SINGLE GATT + single listener slot, so two sessions can
+ // never physically overlap. This mutex enforces that at the API level: every session serializes, so an
+ // out-of-band caller (e.g. a bolus cancel fired off the queue worker by cancelAllBoluses) waits for the
+ // in-flight session to close and release before it opens — never a two-GATT status-133 collision.
+ private val sessionMutex = Mutex()
+
+ // Test seam: the per-session scope dispatcher. Production always uses IO; tests inject a
+ // TestDispatcher so the event-router subscription and frame emissions are deterministically ordered
+ // (the events SharedFlow has no replay, so a frame emitted before the router subscribes is lost —
+ // impossible against real-radio latencies, but instant fake responses can hit it).
+ internal var sessionDispatcher: CoroutineDispatcher = Dispatchers.IO
+
+ // Wall-clock of the last session close, for the inter-session settle below.
+ @Volatile private var lastCloseAtMs = 0L
+
+ /**
+ * Handler for unsolicited notifications (alarms, stop/basal-restart reports) received while a session
+ * is open — the [BleClient.unsolicitedEvents] bridge the BLE migration dropped. Set by the pump plugin
+ * on start, cleared on stop. Invoked on the session's IO scope; the handler MUST NOT start another BLE
+ * session ([withSession] holds [sessionMutex] for its whole duration, so a nested session self-deadlocks).
+ */
+ @Volatile var unsolicitedHandler: ((UnsolicitedMessage) -> Unit)? = null
+
+ private val _connected = MutableStateFlow(false)
+ /**
+ * Queue-owned held-link state: true only while [openLink]'s held link is up — NOT for transient per-op
+ * sessions ([transientSession]). The coordinator reports this as `Pump.isConnected` post-activation, so
+ * a transient op must never flip it (else the queue would skip connect() and re-dial per op).
+ */
+ val connected: StateFlow = _connected.asStateFlow()
+
+ private val _lastConnectedAt = MutableStateFlow(0L)
+ /** Wall-clock (ms) of the last time a session reached CONNECTED — the "last connection" reachability signal. */
+ val lastConnectedAt: StateFlow = _lastConnectedAt.asStateFlow()
+
+ // ===== Queue-owned held link (CommandQueue lifecycle) =====
+ // The AAPS CommandQueue (QueueWorker) drives connect() → run ops → disconnect(). openLink holds ONE
+ // session open across a whole queue-busy burst; ops reuse it via withSession (no per-op re-dial), and the
+ // queue's disconnect() closes it. The new stack dials autoConnect=false with no self-reconnect, so a close
+ // stays closed and the queue is the sole reconnect driver. See _docs/CARELEVO_QUEUE_OWNED_LINK.md.
+
+ // Test seam (mirrors sessionDispatcher): the dispatcher for queue-driven connect/disconnect kicks.
+ // Production uses IO; tests inject the shared test dispatcher so requestConnect's async openLink is drivable.
+ internal var linkDispatcher: CoroutineDispatcher = Dispatchers.IO
+ /** App-lifetime scope for queue-driven connect/disconnect kicks (never a per-session scope). */
+ private val linkScope: CoroutineScope by lazy { CoroutineScope(linkDispatcher + SupervisorJob()) }
+
+ // True while a queue-driven connect attempt is in flight; its compareAndSet also guards against piling
+ // up overlapping connect launches (feeds `Pump.isConnecting` via the coordinator).
+ private val _connecting = MutableStateFlow(false)
+ val isConnecting: StateFlow = _connecting.asStateFlow()
+
+ /** The in-flight connect job, so [requestDisconnect]/stopConnecting can cancel a slow/hung openLink. */
+ @Volatile private var connectJob: Job? = null
+
+ private class HeldLink(
+ val gatt: BleTransportGattConnection,
+ val client: BleClient,
+ val scope: CoroutineScope
+ )
+
+ /** The currently held queue-owned link, or null when no session is up. */
+ @Volatile private var heldLink: HeldLink? = null
+
+ /** Read Infusion Info (0x31 → 0x91) — the periodic status read (reservoir, totals, pump state). */
+ suspend fun readInfusionInfo(address: String): InfusionInfoResponse =
+ withSession(address, "infusion info") { it.request(InfusionInfoCommand()) }
+
+ /** Run any single-response [command] (write or read) on a fresh session. */
+ suspend fun runSingle(address: String, command: BleCommand, timeoutMs: Long = READ_TIMEOUT_MS): R =
+ withSession(address, command::class.simpleName ?: "command", timeoutMs) { it.request(command) }
+
+ /**
+ * Run the streaming Safety Check (0x12 → 0x72). [onFrame] is invoked for every decoded frame (each
+ * progress report and the terminal SUCCESS/error) as the pump reports it; the stream completes on the
+ * terminal frame. Uses a long timeout — the check runs ~100-210 s.
+ */
+ suspend fun runSafetyCheck(address: String, onFrame: (SafetyCheckResponse) -> Unit) =
+ withSession(address, "safety check", SAFETY_CHECK_TIMEOUT_MS) { client ->
+ client.requestStream(SafetyCheckCommand()).collect { onFrame(it) }
+ }
+
+ /**
+ * Write a full basal program — the initial set (activation, 0x13 → 0x73, [isUpdate] = false) or the
+ * mid-therapy profile update (0x21 → 0x81, [isUpdate] = true; the V2 update sends the same 3-write
+ * shape as set, just under the change opcode). A full program is **three sequential
+ * [BasalProgramCommand]s** (seqNo 0, 1, 2) that MUST share ONE connection, so — unlike [runSingle] —
+ * all three run inside a single session. [programs] are the per-seqNo segment-speed lists (v2 sends
+ * speed only). Returns true only if every write reports `resultCode == 0`; short-circuits on the first
+ * failure (`all` stops early) so a rejected seqNo does not send the rest of a partial program.
+ */
+ suspend fun runBasalProgram(address: String, programs: List>, isUpdate: Boolean = false): Boolean =
+ withSession(address, "basal program", BASAL_PROGRAM_TIMEOUT_MS) { client ->
+ programs.withIndex().all { (index, speeds) ->
+ client.request(BasalProgramCommand(isUpdate = isUpdate, seqNo = index, segmentSpeeds = speeds)).resultCode == RESULT_SUCCESS
+ }
+ }
+
+ /**
+ * Pair a factory-fresh patch, all on ONE session: connect → **create the Android bond**
+ * (`ensureBond`; the patch requires the bond be created after CONNECTED, before discovery) →
+ * discover → enable notifications → MAC read (0x3B) → checksum app-auth (0x4B) → set-time→patch-info
+ * rounds (0x11 → 0x93+0x94, retried while the serial is empty) → alert-alarm mode (0x48) →
+ * threshold bundle (0x1B). Persistence is NOT done here — the caller feeds the returned
+ * [PairingResult] to `CarelevoConnectNewPatchUseCase.persistNewPatch`.
+ */
+ suspend fun runPairing(address: String, spec: PairingSpec): PairingResult =
+ withSession(address, "pairing", PAIRING_TIMEOUT_MS, ensureBond = true) { client ->
+ val key = (0..255).random()
+ val macResponse = client.request(MacAddressCommand(key.toByte()))
+ // The persisted MAC is lowercase, colon-separated.
+ val colonMac = macResponse.macAddress.lowercase().chunked(2).joinToString(":")
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: pairing MAC=$colonMac")
+ val checkSumByte = (macResponse.macAddress + macResponse.checkSum).convertHexToByteArray().checkSumV2(key)
+ val auth = client.request(AppAuthCommand(checkSumByte.toUByte().toInt()))
+ check(auth.resultCode == RESULT_SUCCESS) { "app auth failed result=${auth.resultCode}" }
+
+ // KNOWN RESIDUAL RISK (accepted): the retry rounds below share ONE live session/collector,
+ // and BleMultiCommand correlation is opcode-only (the 0x93/0x94 frames carry no round or
+ // correlation byte the wire protocol could check). A round-1 frame arriving AFTER its own
+ // 10 s window expired could therefore satisfy one of round-2's expected opcodes and mix
+ // round-1/round-2 data (e.g. round-1 serial + round-2 firmware). The window is a frame
+ // delayed >10 s but landing exactly inside the next round — unobserved on real hardware,
+ // and a fresh session per round would repeat MAC/auth against a factory-fresh patch for a
+ // worse trade. If it ever bites, the pairing result is rejected by the serial/detail
+ // result-code checks below or caught at first status read.
+ var patchInfo: PatchInfoResponse? = null
+ for (round in 1..PATCH_INFO_ROUND_RETRY_COUNT) {
+ val info = withTimeoutOrNull(PATCH_INFO_ROUND_TIMEOUT_MS.milliseconds) {
+ client.requestMultiple(SetTimeForPatchInfoCommand(subId = 0, volume = spec.volume, aidMode = 0, dateTime = DateTime.now()))
+ }
+ if (info != null && info.serialResultCode == RESULT_SUCCESS && info.serialNumber.trim().isNotEmpty() && info.detailResultCode == RESULT_SUCCESS) {
+ patchInfo = info
+ break
+ }
+ aapsLogger.warn(
+ LTag.PUMPCOMM,
+ "bleSession: invalid patch info round=$round/$PATCH_INFO_ROUND_RETRY_COUNT " +
+ "result=${info?.serialResultCode} serial=${info?.serialNumber?.trim()} detailResult=${info?.detailResultCode}"
+ )
+ }
+ val info = patchInfo ?: throw IllegalStateException("patch info invalid after $PATCH_INFO_ROUND_RETRY_COUNT rounds")
+
+ val alarm = client.request(AlertAlarmSetCommand(ALERT_ALARM_MODE_DEFAULT))
+ check(alarm.resultCode == RESULT_SUCCESS) { "alert alarm set failed result=${alarm.resultCode}" }
+ val threshold = client.request(
+ ThresholdSetupCommand(
+ insulinRemainsThreshold = spec.remains,
+ expiryThreshold = spec.expiry,
+ maxBasalSpeed = spec.maxBasalSpeed,
+ maxBolusDose = spec.maxBolusDose,
+ buzzUse = spec.buzzUse
+ )
+ )
+ check(threshold.resultCode == RESULT_SUCCESS) { "threshold setup failed result=${threshold.resultCode}" }
+
+ PairingResult(
+ address = colonMac,
+ serialNumber = info.serialNumber.trim(),
+ firmwareVersion = info.firmwareVersion,
+ modelName = info.modelName
+ )
+ }
+
+ /** Inputs of the activation threshold/set-time writes. */
+ data class PairingSpec(
+ val volume: Int,
+ val remains: Int,
+ val expiry: Int,
+ val maxBasalSpeed: Double,
+ val maxBolusDose: Double,
+ val buzzUse: Boolean
+ )
+
+ /** Identity of the freshly paired patch, decoded from the 0x9B + 0x93/0x94 responses. */
+ data class PairingResult(
+ val address: String,
+ val serialNumber: String,
+ val firmwareVersion: String,
+ val modelName: String
+ )
+
+ /**
+ * Fire ONE connect attempt and return — the queue re-polls [connected] until true (matching the
+ * Dash/Medtrum `connect()` contract). Idempotent: no-ops while a link is already up or a connect is
+ * in flight. Called from the QueueWorker thread via the coordinator's `connect()`.
+ */
+ fun requestConnect(address: String, reason: String) {
+ if (_connected.value || !_connecting.compareAndSet(false, true)) return
+ connectJob = linkScope.launch {
+ try {
+ openLink(address, reason)
+ } catch (c: CancellationException) {
+ throw c // aborted by requestDisconnect/stopConnecting — not an error
+ } catch (t: Throwable) {
+ aapsLogger.error(LTag.PUMPCOMM, "bleSession: openLink failed reason=$reason", t)
+ } finally {
+ _connecting.value = false
+ }
+ }
+ }
+
+ /**
+ * Close the held link (queue `disconnect()` / `stopConnecting()`). Also cancels any in-flight
+ * [openLink] so a slow/hung connect is aborted promptly rather than briefly opening the link first.
+ */
+ fun requestDisconnect(reason: String) {
+ connectJob?.cancel()
+ connectJob = null
+ linkScope.launch { sessionMutex.withLock { tearDownHeld(reason) } }
+ }
+
+ /**
+ * Open the queue-owned held link — one attempt, then leave it up for [withSession] to reuse until the
+ * queue's `disconnect()` (or an unexpected drop) closes it. Holds [sessionMutex] for the handshake so no
+ * transient session can race it onto the transport's single GATT.
+ */
+ private suspend fun openLink(address: String, reason: String) = sessionMutex.withLock {
+ if (heldLink != null) return@withLock
+ awaitInterSessionSettle()
+ val mac = address.uppercase()
+ val scope = CoroutineScope(sessionDispatcher + SupervisorJob())
+ val gatt = BleTransportGattConnection(transport, writeUuid, notifyUuid, scope)
+ val client: BleClient = BleClientImpl(gatt, writeUuid, notifyUuid, scope)
+ subscribeUnsolicited(scope, client)
+ try {
+ withTimeout(CONNECT_TIMEOUT_MS.milliseconds) { open(gatt, mac) }
+ } catch (t: Throwable) {
+ // Half-open handshake: release the fresh gatt + scope (one-shot close) so the next queue
+ // connect() starts clean.
+ gatt.close()
+ scope.cancel()
+ lastCloseAtMs = System.currentTimeMillis()
+ throw t
+ }
+ heldLink = HeldLink(gatt, client, scope)
+ // Subscribe the drop watcher (UNDISPATCHED → live synchronously) BEFORE marking the link up, so a
+ // DISCONNECTED racing the handshake can't slip through the replay-0 events flow with no subscriber.
+ watchForDrop(scope, gatt)
+ _lastConnectedAt.value = System.currentTimeMillis()
+ _connected.value = true
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: held link up reason=$reason")
+ }
+
+ /**
+ * Flip [connected] false and release the link on an unexpected drop (out-of-range / patch sleep), so
+ * the queue re-dials on its next command. Runs on the held session scope; the tear-down hops onto
+ * [linkScope] so it survives that scope's own cancellation.
+ */
+ private fun watchForDrop(scope: CoroutineScope, gatt: BleTransportGattConnection) {
+ // UNDISPATCHED so the flow subscription registers synchronously on the calling thread (like open()'s
+ // CONNECTED wait) — the collector is live before this returns, closing the replay-0 lost-event window.
+ scope.launch(start = CoroutineStart.UNDISPATCHED) {
+ gatt.events
+ .filterIsInstance()
+ .first { it.state == GattConnState.DISCONNECTED }
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: held link dropped")
+ linkScope.launch { sessionMutex.withLock { tearDownHeld("dropped") } }
+ }
+ }
+
+ /** Idempotent teardown of the held link. Caller holds [sessionMutex]. */
+ private fun tearDownHeld(reason: String) {
+ val link = heldLink ?: return
+ _connected.value = false
+ link.gatt.close()
+ link.scope.cancel()
+ lastCloseAtMs = System.currentTimeMillis()
+ heldLink = null
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: held link closed reason=$reason")
+ }
+
+ /**
+ * Run [block] against a [BleClient]. Reuses the queue-owned held link when one is up (no open/close —
+ * the queue owns teardown); otherwise falls back to a [transientSession] (open→run→close). [ensureBond]
+ * (pairing) always forces a fresh transient session.
+ */
+ private suspend fun withSession(
+ address: String,
+ label: String,
+ timeoutMs: Long = READ_TIMEOUT_MS,
+ ensureBond: Boolean = false,
+ block: suspend (BleClient) -> R
+ ): R =
+ sessionMutex.withLock {
+ val link = heldLink
+ if (link != null && !ensureBond) {
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: $label on held link")
+ try {
+ withTimeout(timeoutMs.milliseconds) { block(link.client) }
+ } catch (t: TimeoutCancellationException) {
+ // Op timed out on the held link → the link is suspect. Drop it so the next queue command
+ // re-dials a fresh GATT (restores the per-op self-heal the held link removed).
+ tearDownHeld("op timed out on held link: $label")
+ throw t
+ } catch (c: CancellationException) {
+ throw c // caller cancelled the op (e.g. StopBolus) — the link is fine, leave it up
+ } catch (t: Throwable) {
+ // GATT write/disconnect failure → the link is dead. Drop it so the next command re-dials.
+ tearDownHeld("op failed on held link: $label")
+ throw t
+ }
+ } else {
+ // A transient session must be the ONLY link on the single-GATT/single-listener transport. If
+ // a held link is somehow up (e.g. an ensureBond pairing while a prior link is still held),
+ // close it first to avoid a second concurrent GATT (status-133) and a stolen listener slot.
+ if (link != null) tearDownHeld("transient session needs the transport: $label")
+ transientSession(address, label, timeoutMs, ensureBond, block)
+ }
+ }
+
+ /**
+ * Per-op session: open a fresh connection, run [block] against the [BleClient], and close. Used for
+ * pre-activation / pairing / any op with no held link. Each call gets its own adapter+client+scope —
+ * see the class KDoc for why (one-shot [BleTransportGattConnection.close]). [ensureBond] (pairing only)
+ * creates the Android bond after CONNECTED, before discovery — the order the patch requires. Caller
+ * holds [sessionMutex].
+ */
+ private suspend fun transientSession(
+ address: String,
+ label: String,
+ timeoutMs: Long,
+ ensureBond: Boolean,
+ block: suspend (BleClient) -> R
+ ): R {
+ awaitInterSessionSettle()
+ // BluetoothAdapter.getRemoteDevice requires an UPPERCASE MAC (lowercase throws
+ // IllegalArgumentException); the stored address is lowercase, so normalize here.
+ val mac = address.uppercase()
+ val scope = CoroutineScope(sessionDispatcher + SupervisorJob())
+ val gatt = BleTransportGattConnection(transport, writeUuid, notifyUuid, scope)
+ val client: BleClient = BleClientImpl(gatt, writeUuid, notifyUuid, scope)
+ subscribeUnsolicited(scope, client)
+ return try {
+ // Bound the ENTIRE connect→discover→enable handshake, not just the CONNECTED wait: a lost
+ // CCCD-write callback (which the transport documents as "surfaced by the caller's withTimeout")
+ // would otherwise suspend forever HERE while holding sessionMutex, wedging every later
+ // session op — including a delivery-critical out-of-band bolus cancel. On timeout the finally closes the
+ // gatt (aborting the pending ack) and releases the mutex.
+ val openTimeoutMs = if (ensureBond) CONNECT_TIMEOUT_MS + BOND_TIMEOUT_MS else CONNECT_TIMEOUT_MS
+ withTimeout(openTimeoutMs.milliseconds) { open(gatt, mac, ensureBond) }
+ // NB: a transient session does NOT touch _connected — that flag is the queue-owned held-link
+ // signal (see [connected]). It updates lastConnectedAt only, since it is a real connection.
+ _lastConnectedAt.value = System.currentTimeMillis()
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: reading $label")
+ withTimeout(timeoutMs.milliseconds) { block(client) }
+ } finally {
+ gatt.close()
+ scope.cancel()
+ lastCloseAtMs = System.currentTimeMillis()
+ }
+ }
+
+ /** Inter-session settle: let the patch fully release the previous link before the next dial (~1 s). */
+ private suspend fun awaitInterSessionSettle() {
+ val sinceCloseMs = System.currentTimeMillis() - lastCloseAtMs
+ if (sinceCloseMs in 0 until INTER_SESSION_SETTLE_MS) delay((INTER_SESSION_SETTLE_MS - sinceCloseMs).milliseconds)
+ }
+
+ /**
+ * Bridge patch-pushed frames (alarms, stop/basal-restart reports) to [unsolicitedHandler] for the life
+ * of [scope]. Subscribed before open() so a frame during the handshake isn't missed; the scope's
+ * cancellation tears this collector down with the session/link.
+ */
+ private fun subscribeUnsolicited(scope: CoroutineScope, client: BleClient) {
+ scope.launch {
+ client.unsolicitedEvents.collect { msg ->
+ try {
+ unsolicitedHandler?.invoke(msg)
+ } catch (t: Throwable) {
+ aapsLogger.error(LTag.PUMPCOMM, "unsolicited handler error", t)
+ }
+ }
+ }
+ }
+
+ private suspend fun open(gatt: BleTransportGattConnection, address: String, ensureBond: Boolean = false) = coroutineScope {
+ // Subscribe to the CONNECTED event BEFORE calling connect() so the state change cannot race
+ // ahead of our collector. UNDISPATCHED runs the async body up to the flow subscription
+ // synchronously, guaranteeing the subscription is live before connect() fires.
+ val connected = async(start = CoroutineStart.UNDISPATCHED) {
+ withTimeout(CONNECT_TIMEOUT_MS.milliseconds) {
+ gatt.events
+ .filterIsInstance()
+ .first { it.state == GattConnState.CONNECTED }
+ }
+ }
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: connecting to $address")
+ require(gatt.connect(address)) { "bleSession: connect() refused for $address" }
+ connected.await()
+ if (ensureBond && !transport.adapter.isDeviceBonded(address)) {
+ // The patch requires the bond be created right after STATE_CONNECTED; the transport exposes
+ // no bond-state callback, so poll isDeviceBonded until the SMP completes.
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: creating bond")
+ transport.adapter.createBond(address)
+ withTimeout(BOND_TIMEOUT_MS.milliseconds) {
+ while (!transport.adapter.isDeviceBonded(address)) delay(BOND_POLL_MS.milliseconds)
+ }
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: bonded")
+ }
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: connected; discovering services")
+ gatt.discoverServices()
+ gatt.enableNotifications(notifyUuid)
+ aapsLogger.debug(LTag.PUMPCOMM, "bleSession: notifications enabled")
+ }
+
+ private companion object {
+
+ const val CONNECT_TIMEOUT_MS = 20_000L
+ const val READ_TIMEOUT_MS = 15_000L
+
+ // Safety check streams progress for ~100-210 s before the terminal frame; give it headroom.
+ const val SAFETY_CHECK_TIMEOUT_MS = 250_000L
+
+ // Three sequential basal-program writes on one connection; generous headroom over READ_TIMEOUT_MS.
+ const val BASAL_PROGRAM_TIMEOUT_MS = 30_000L
+ private const val RESULT_SUCCESS = 0
+
+ // Pairing: MAC read + auth + up to 2 patch-info rounds (10 s each) + alarm + threshold;
+ // bond wait is bounded separately in open().
+ const val PAIRING_TIMEOUT_MS = 45_000L
+ private const val PATCH_INFO_ROUND_RETRY_COUNT = 2
+ private const val PATCH_INFO_ROUND_TIMEOUT_MS = 10_000L
+ private const val BOND_TIMEOUT_MS = 15_000L
+ private const val BOND_POLL_MS = 250L
+
+ // Activation sends alert-alarm mode 0.
+ private const val ALERT_ALARM_MODE_DEFAULT = 0
+
+ // Minimum gap between one session's close and the next session's connect (patch-side settle).
+ private const val INTER_SESSION_SETTLE_MS = 1000L
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/CarelevoBleTransport.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/CarelevoBleTransport.kt
new file mode 100644
index 000000000000..95684b3329d7
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/CarelevoBleTransport.kt
@@ -0,0 +1,26 @@
+package app.aaps.pump.carelevo.ble
+
+import app.aaps.core.interfaces.pump.ble.BleTransport
+
+/**
+ * CareLevo-specific extension of the shared fleet [BleTransport].
+ *
+ * CareLevo runs on the shared fleet [BleTransport] (the same abstraction Dana/Equil/Medtrum use);
+ * the coroutine correlation layer lives in [BleClient] above the transport.
+ *
+ * Adds the two fields the fleet impls carry that aren't part of the generic interface:
+ * - [scanAddress]: MAC filter for [app.aaps.core.interfaces.pump.ble.BleScanner.startScan]
+ * - [onGattError133]: hook for the status-133 bond-lock workaround
+ *
+ * Implemented by [CarelevoBleTransportImpl] (production). A future
+ * `CarelevoEmulatorBleTransport` in a `:pump:carelevo-emulator` module can implement the same
+ * interface for hardware-free testing, swapped in via DI exactly like Dana/Equil.
+ */
+interface CarelevoBleTransport : BleTransport {
+
+ /** MAC address filter for scanning. Set before calling `scanner.startScan()`. */
+ var scanAddress: String?
+
+ /** Called when GATT error 133 occurs, before `onConnectionStateChanged(false)`. */
+ var onGattError133: (() -> Unit)?
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/CarelevoBleTransportImpl.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/CarelevoBleTransportImpl.kt
new file mode 100644
index 000000000000..38d73faf9f96
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/CarelevoBleTransportImpl.kt
@@ -0,0 +1,349 @@
+package app.aaps.pump.carelevo.ble
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothGattCallback
+import android.bluetooth.BluetoothGattCharacteristic
+import android.bluetooth.BluetoothGattDescriptor
+import android.bluetooth.BluetoothManager
+import android.bluetooth.BluetoothProfile
+import android.bluetooth.BluetoothStatusCodes
+import android.bluetooth.le.ScanCallback
+import android.bluetooth.le.ScanFilter
+import android.bluetooth.le.ScanResult
+import android.bluetooth.le.ScanSettings
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.ParcelUuid
+import android.os.SystemClock
+import androidx.core.app.ActivityCompat
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.pump.ble.BleAdapter
+import app.aaps.core.interfaces.pump.ble.BleGatt
+import app.aaps.core.interfaces.pump.ble.BleScanner
+import app.aaps.core.interfaces.pump.ble.BleTransportListener
+import app.aaps.core.interfaces.pump.ble.PairingState
+import app.aaps.core.interfaces.pump.ble.ScannedDevice
+import app.aaps.pump.carelevo.config.BleEnvConfig
+import app.aaps.pump.carelevo.ext.convertBytesToHex
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import java.util.UUID
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Production [CarelevoBleTransport] over Android's `BluetoothGatt`.
+ *
+ * Structurally a clone of `EquilBleTransportImpl` — carelevo is the same single-service /
+ * single-write-characteristic / single-notify-characteristic patch-pump shape, so the fleet
+ * template maps 1:1. The three sub-interfaces are private inner classes sharing the impl's
+ * mutable GATT state, and the single [BluetoothGattCallback] fans every event out to one
+ * [BleTransportListener] (the [app.aaps.pump.carelevo.ble.gatt.BleTransportGattConnection]
+ * adapter, which bridges into the [BleClient] correlation layer).
+ *
+ * UUIDs come from [BleEnvConfig]: service `e1b40001`, write char (rx) `e1b40002`,
+ * notify char (tx) `e1b40003`, CCCD `2902`. Notifications (not indications), no MTU negotiation.
+ */
+@SuppressLint("MissingPermission")
+@Singleton
+class CarelevoBleTransportImpl @Inject constructor(
+ private val context: Context,
+ private val aapsLogger: AAPSLogger
+) : CarelevoBleTransport {
+
+ private val bluetoothAdapter: BluetoothAdapter?
+ get() = (context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager?)?.adapter
+
+ private var listener: BleTransportListener? = null
+ private var bluetoothGatt: BluetoothGatt? = null
+ private var notifyChara: BluetoothGattCharacteristic? = null
+ private var writeChara: BluetoothGattCharacteristic? = null
+
+ override var scanAddress: String? = null
+ override var onGattError133: (() -> Unit)? = null
+
+ @Suppress("deprecation", "OVERRIDE_DEPRECATION")
+ private val gattCallback = object : BluetoothGattCallback() {
+
+ @Synchronized
+ override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
+ if (status == 133) {
+ aapsLogger.debug(LTag.PUMPBTCOMM, "GATT error 133, removing bond")
+ scanAddress?.let { adapter.removeBond(it) }
+ SystemClock.sleep(50) // Give BT stack time to process bond removal
+ onGattError133?.invoke()
+ listener?.onConnectionStateChanged(false)
+ return
+ }
+ listener?.onConnectionStateChanged(newState == BluetoothProfile.STATE_CONNECTED)
+ }
+
+ @Synchronized
+ override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
+ if (status != BluetoothGatt.GATT_SUCCESS) {
+ aapsLogger.debug(LTag.PUMPBTCOMM, "onServicesDiscovered received: $status")
+ listener?.onServicesDiscovered(false)
+ return
+ }
+ val service = gatt.getService(SERVICE_UUID)
+ if (service != null) {
+ notifyChara = service.getCharacteristic(TX_CHAR_UUID)
+ writeChara = service.getCharacteristic(RX_CHAR_UUID)
+ }
+ listener?.onServicesDiscovered(service != null && notifyChara != null && writeChara != null)
+ }
+
+ override fun onCharacteristicWrite(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) {
+ listener?.onCharacteristicWritten()
+ }
+
+ override fun onCharacteristicRead(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) {
+ listener?.onCharacteristicChanged(characteristic.value)
+ }
+
+ override fun onCharacteristicChanged(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic) {
+ val data = characteristic.value
+ // Log every inbound frame (opcode = first byte) so patch-pushed notifications — alarms and the
+ // auto-resume report — are visible even though the unsolicited path is not yet consumed. The
+ // pre-migration driver logged incoming frames here; the transport migration dropped it.
+ aapsLogger.debug(LTag.PUMPBTCOMM, "onCharacteristicChanged incoming: ${data.convertBytesToHex()}")
+ listener?.onCharacteristicChanged(data)
+ }
+
+ @Synchronized
+ override fun onDescriptorWrite(gatt: BluetoothGatt, descriptor: BluetoothGattDescriptor, status: Int) {
+ aapsLogger.debug(LTag.PUMPBTCOMM, "onDescriptorWrite received: $status")
+ if (status == BluetoothGatt.GATT_SUCCESS) {
+ listener?.onDescriptorWritten()
+ }
+ }
+ }
+
+ // --- BleTransport ---
+
+ override val adapter: BleAdapter = CarelevoAdapterImpl()
+ override val scanner: BleScanner = CarelevoScannerImpl()
+ override val gatt: BleGatt = CarelevoGattImpl()
+
+ private val _pairingState = MutableStateFlow(PairingState())
+ override val pairingState: StateFlow = _pairingState
+
+ override fun updatePairingState(state: PairingState) {
+ _pairingState.value = state
+ }
+
+ override fun setListener(listener: BleTransportListener?) {
+ val existing = this.listener
+ if (existing != null && listener != null && existing !== listener) {
+ // This @Singleton holds a single listener slot; a new adapter registering before the
+ // previous one closed would silently orphan it (its in-flight ops would hang). This is a
+ // defensive guard against that overlap.
+ aapsLogger.warn(LTag.PUMPBTCOMM, "setListener overwriting an active listener; previous connection not closed?")
+ }
+ this.listener = listener
+ }
+
+ // --- BleAdapter ---
+
+ private inner class CarelevoAdapterImpl : BleAdapter {
+
+ override fun enable() {
+ // not used by CareLevo
+ }
+
+ override fun getDeviceName(address: String): String? {
+ if (!hasPermission(Manifest.permission.BLUETOOTH_CONNECT)) return null
+ return bluetoothAdapter?.getRemoteDevice(address)?.name
+ }
+
+ override fun isDeviceBonded(address: String): Boolean {
+ if (!hasPermission(Manifest.permission.BLUETOOTH_CONNECT)) return false
+ val device = bluetoothAdapter?.getRemoteDevice(address) ?: return false
+ return device.bondState == BluetoothDevice.BOND_BONDED
+ }
+
+ override fun createBond(address: String): Boolean {
+ if (!hasPermission(Manifest.permission.BLUETOOTH_CONNECT)) return false
+ val device = bluetoothAdapter?.getRemoteDevice(address) ?: return false
+ return device.createBond()
+ }
+
+ override fun removeBond(address: String) {
+ if (!hasPermission(Manifest.permission.BLUETOOTH_CONNECT)) return
+ try {
+ val pairedDevices = bluetoothAdapter?.bondedDevices ?: return
+ for (device in pairedDevices) {
+ if (device.address == address) {
+ val method = device.javaClass.getMethod("removeBond")
+ method.invoke(device)
+ }
+ }
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "Error removing bond", e)
+ }
+ }
+ }
+
+ // --- BleScanner ---
+
+ private inner class CarelevoScannerImpl : BleScanner {
+
+ private var scanCallback: ScanCallback? = null
+ private val _scannedDevices = MutableSharedFlow(extraBufferCapacity = 10)
+ override val scannedDevices: SharedFlow = _scannedDevices
+
+ override fun startScan() {
+ if (!hasPermission(Manifest.permission.BLUETOOTH_SCAN)) return
+
+ scanCallback = object : ScanCallback() {
+ override fun onScanResult(callbackType: Int, result: ScanResult) {
+ val name = result.device?.name
+ if (name?.isNotEmpty() == true) {
+ _scannedDevices.tryEmit(
+ ScannedDevice(
+ name = name,
+ address = result.device.address,
+ scanRecordBytes = result.scanRecord?.bytes,
+ rssi = result.rssi
+ )
+ )
+ }
+ }
+ }
+
+ try {
+ val mac = scanAddress
+ val filters = if (mac.isNullOrEmpty()) {
+ // Discovery scan: filter by service UUID (pairing wizard)
+ listOf(
+ ScanFilter.Builder()
+ .setServiceUuid(ParcelUuid(SERVICE_UUID))
+ .build()
+ )
+ } else {
+ // Reconnection scan: filter by MAC address
+ listOf(
+ ScanFilter.Builder()
+ .setDeviceAddress(mac)
+ .build()
+ )
+ }
+ val settings = ScanSettings.Builder()
+ .setReportDelay(0)
+ .build()
+ bluetoothAdapter?.bluetoothLeScanner?.startScan(filters, settings, scanCallback)
+ } catch (_: IllegalStateException) {
+ // BT not on
+ }
+ }
+
+ override fun stopScan() {
+ try {
+ scanCallback?.let { bluetoothAdapter?.bluetoothLeScanner?.stopScan(it) }
+ } catch (_: IllegalStateException) {
+ // BT not on
+ }
+ scanCallback = null
+ }
+ }
+
+ // --- BleGatt ---
+
+ private inner class CarelevoGattImpl : BleGatt {
+
+ override fun connect(address: String): Boolean {
+ if (!hasPermission(Manifest.permission.BLUETOOTH_CONNECT)) return false
+ val device = bluetoothAdapter?.getRemoteDevice(address) ?: return false
+ // Release any previous client before opening a new one. Android caps concurrent GATT
+ // client interfaces; leaking them (connectGatt without close) leads to status 133 and
+ // an eventual inability to connect at all.
+ bluetoothGatt?.close()
+ bluetoothGatt = device.connectGatt(context, false, gattCallback, BluetoothDevice.TRANSPORT_LE)
+ return bluetoothGatt != null
+ }
+
+ override fun disconnect() {
+ bluetoothGatt?.disconnect()
+ }
+
+ override fun close() {
+ bluetoothGatt?.close()
+ bluetoothGatt = null
+ notifyChara = null
+ writeChara = null
+ }
+
+ override fun discoverServices() {
+ bluetoothGatt?.discoverServices()
+ }
+
+ override fun findCharacteristics(): Boolean {
+ return notifyChara != null && writeChara != null
+ }
+
+ @Suppress("deprecation")
+ override fun enableNotifications() {
+ val chara = notifyChara ?: return
+ val gatt = bluetoothGatt ?: return
+ val result = gatt.setCharacteristicNotification(chara, true)
+ if (result) {
+ val descriptor = chara.getDescriptor(CCCD_UUID) ?: return
+ val writeStarted = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ gatt.writeDescriptor(descriptor, BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE) == BluetoothStatusCodes.SUCCESS
+ } else {
+ descriptor.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+ gatt.writeDescriptor(descriptor)
+ }
+ if (!writeStarted) {
+ aapsLogger.debug(LTag.PUMPBTCOMM, "enableNotifications: writeDescriptor could not start")
+ }
+ }
+ }
+
+ @Suppress("deprecation")
+ override fun writeCharacteristic(data: ByteArray) {
+ val chara = writeChara
+ val gatt = bluetoothGatt
+ if (chara == null || gatt == null) {
+ aapsLogger.debug(LTag.PUMPBTCOMM, "writeCharacteristic: not connected")
+ listener?.onConnectionStateChanged(false)
+ return
+ }
+ // setValue-then-write is NOT atomic on the shared characteristic object; it is safe only
+ // because BleTransportGattConnection.gattMutex serializes all suspend GATT ops. Do not
+ // decouple this transport from that serialization without adding one here.
+ val writeStarted = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ gatt.writeCharacteristic(chara, data, chara.writeType) == BluetoothStatusCodes.SUCCESS
+ } else {
+ chara.value = data
+ gatt.writeCharacteristic(chara)
+ }
+ if (!writeStarted) {
+ aapsLogger.debug(LTag.PUMPBTCOMM, "writeCharacteristic: writeCharacteristic could not start")
+ }
+ }
+
+ override fun requestConnectionPriority(priority: Int) {
+ bluetoothGatt?.requestConnectionPriority(priority)
+ }
+ }
+
+ private fun hasPermission(permission: String): Boolean =
+ ActivityCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
+
+ private companion object {
+
+ private val SERVICE_UUID: UUID = UUID.fromString(BleEnvConfig.BLE_SERVICE_UUID)
+ private val TX_CHAR_UUID: UUID = UUID.fromString(BleEnvConfig.BLE_TX_CHAR_UUID)
+ private val RX_CHAR_UUID: UUID = UUID.fromString(BleEnvConfig.BLE_RX_CHAR_UUID)
+ private val CCCD_UUID: UUID = UUID.fromString(BleEnvConfig.BLE_CCC_DESCRIPTOR)
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AdditionalPrimingCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AdditionalPrimingCommand.kt
new file mode 100644
index 000000000000..a6b44b3d684f
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AdditionalPrimingCommand.kt
@@ -0,0 +1,34 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_ADD_PRIMING_REQ` (0x1D) → `CMD_ADD_PRIMING_RES` (0x7D). Requests an additional priming pulse on the
+ * patch (medium criticality) — used to top up priming when the initial prime was insufficient.
+ *
+ * Request wire format (1 byte): `[0] 0x1D` — opcode alone, no arguments to encode or range-check.
+ *
+ * Response (0x7D): `[0] 0x7D, [1] resultCode` → [SimpleResultResponse] (`resultCode` 0 = SUCCESS).
+ *
+ * Note: the pump later emits an unsolicited `0x98` PulseFinish notification when priming completes; that is a
+ * separate message and is **not** part of this request/response pair.
+ */
+class AdditionalPrimingCommand : BleCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode)
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x1D
+ const val RESPONSE_OPCODE: Byte = 0x7D
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AlarmClearCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AlarmClearCommand.kt
new file mode 100644
index 000000000000..6eb03cc4d9b5
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AlarmClearCommand.kt
@@ -0,0 +1,55 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+
+/**
+ * `CMD_ALARM_CLEAR_REQ` (0x47) → `CMD_ALARM_CLEAR_RES` (0xA7). Clears a raised patch alarm.
+ * Criticality: medium.
+ *
+ * Request wire format (3 bytes): `[0] 0x47, [1] alarmType, [2] cause`.
+ * - `alarmType` — raw byte, **no range check**, so values > 0x7F pass straight through as the
+ * two's-complement byte.
+ * - `cause` — range-checked `0..100`.
+ *
+ * Response (0xA7): `[0] 0xA7, [1] subId, [2] cause, [3] resultCode`. `resultCode` 0 = SUCCESS;
+ * consumers map it.
+ */
+class AlarmClearCommand(
+ private val alarmType: Int,
+ private val cause: Int
+) : BleCommand {
+
+ init {
+ require(cause in CAUSE_RANGE) { "cause $cause out of range $CAUSE_RANGE" }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode, alarmType.toByte(), cause.toByte())
+
+ override fun decode(responsePayload: ByteArray): AlarmClearResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return AlarmClearResponse(
+ subId = responsePayload.u(1),
+ cause = responsePayload.u(2),
+ resultCode = responsePayload.u(3)
+ )
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x47
+ const val RESPONSE_OPCODE: Byte = 0xA7.toByte()
+ private val CAUSE_RANGE = 0..100
+ private const val MIN_RESPONSE_LENGTH = 4
+ }
+}
+
+/** Decoded response from [AlarmClearCommand]: echoed [subId] + [cause], plus pump [resultCode] (0 = SUCCESS). */
+data class AlarmClearResponse(
+ val subId: Int,
+ val cause: Int,
+ val resultCode: Int
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AlertAlarmSetCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AlertAlarmSetCommand.kt
new file mode 100644
index 000000000000..0921b8c1fb67
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AlertAlarmSetCommand.kt
@@ -0,0 +1,36 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_ALERT_ALARM_SET_REQ` (0x48) → `CMD_ALERT_ALARM_SET_RES` (0xA8). Sets the patch alert/alarm mode.
+ * Medium criticality.
+ *
+ * Request wire format (2 bytes): `[0] 0x48, [1] mode` — [mode] is written as a **raw byte**.
+ *
+ * **Quirk — no range validation:** [mode] is not range-checked; it is emitted as `mode.toByte()`
+ * verbatim, so values > 0x7F wrap on the wire.
+ *
+ * Response (0xA8): `[0] 0xA8, [1] resultCode` → [SimpleResultResponse] (0 = SUCCESS).
+ */
+class AlertAlarmSetCommand(
+ private val mode: Int
+) : BleCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode, mode.toByte())
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x48
+ const val RESPONSE_OPCODE: Byte = 0xA8.toByte()
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AppAuthCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AppAuthCommand.kt
new file mode 100644
index 000000000000..e841c2da5e9b
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/AppAuthCommand.kt
@@ -0,0 +1,46 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_APP_AUTH_IND` (0x4B) → `CMD_APP_AUTH_ACK` (0xBB). The activation app-auth handshake: the app sends its
+ * auth [key] and the patch acknowledges with a result code.
+ *
+ * Request wire format (2 bytes): `[0] 0x4B, [1] key` — [key] is written as a **raw byte**, with no
+ * scaling/inversion applied.
+ *
+ * **Opcode quirk:** the request opcode is 0x4B, but the reply comes back on `CMD_APP_AUTH_ACK` = **0xBB**
+ * (not 0x4B, and not the neighbouring `CMD_APP_AUTH_KEY_ACK` = 0xBA), which is why [expectedResponseOpcode]
+ * is 0xBB rather than echoing the request opcode.
+ *
+ * Response (0xBB): `[0] 0xBB, [1] result` → [SimpleResultResponse] (0 = SUCCESS). Only the wire [result]
+ * byte is carried.
+ */
+class AppAuthCommand(
+ private val key: Int
+) : BleCommand {
+
+ init {
+ require(key in KEY_RANGE) { "key $key out of range $KEY_RANGE" }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode, key.toByte())
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x4B
+ const val RESPONSE_OPCODE: Byte = 0xBB.toByte()
+
+ // key is written as a raw byte; accept the full unsigned-byte range.
+ private val KEY_RANGE = 0..255
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/BasalProgramCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/BasalProgramCommand.kt
new file mode 100644
index 000000000000..02cfca5ac69e
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/BasalProgramCommand.kt
@@ -0,0 +1,50 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * Basal-program write (v2 encoding). One command class for both:
+ * - [isUpdate] = `false`: `CMD_BASAL_PROGRAM_REQ1` (0x13) → `RES1` (0x73) — set the initial program (activation)
+ * - [isUpdate] = `true`: `CMD_BASAL_CHANGE_REQ1` (0x21) → `RES1` (0x81) — update an existing program
+ *
+ * A full basal program is sent as **three sequential [BasalProgramCommand]s** ([seqNo] 0, 1, 2) — that
+ * orchestration lives in the caller, not here (this is NOT a multi-response command; each write gets its
+ * own single response).
+ *
+ * Request wire format: `[0] opcode, [1] seqNo, [2..] segments` where each segment is `[speedInt, speedCenti]`
+ * (v2 `BasalProgramToByteV2` = `encodeUnitCenti(injectSpeed)`, HALF_UP; no hour/min bytes in v2).
+ * Response: `[0] opcode, [1] resultCode` → [SimpleResultResponse].
+ */
+class BasalProgramCommand(
+ private val isUpdate: Boolean,
+ private val seqNo: Int,
+ private val segmentSpeeds: List
+) : BleCommand {
+
+ init {
+ require(seqNo in SEQ_NO_RANGE) { "seqNo out of range $SEQ_NO_RANGE" }
+ require(segmentSpeeds.isNotEmpty()) { "segmentSpeeds must not be empty" }
+ }
+
+ override val requestOpcode: Byte = if (isUpdate) UPDATE_REQUEST_OPCODE else SET_REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = if (isUpdate) UPDATE_RESPONSE_OPCODE else SET_RESPONSE_OPCODE
+
+ override fun encode(): ByteArray =
+ byteArrayOf(requestOpcode, seqNo.toByte()) +
+ segmentSpeeds.flatMap { encodeUnitCenti(it).asList() }.toByteArray()
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, expectedResponseOpcode, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val SET_REQUEST_OPCODE: Byte = 0x13
+ const val SET_RESPONSE_OPCODE: Byte = 0x73
+ const val UPDATE_REQUEST_OPCODE: Byte = 0x21
+ const val UPDATE_RESPONSE_OPCODE: Byte = 0x81.toByte()
+ private val SEQ_NO_RANGE = 0..2
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/BolusCancelCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/BolusCancelCommand.kt
new file mode 100644
index 000000000000..d647884619d7
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/BolusCancelCommand.kt
@@ -0,0 +1,51 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+
+/**
+ * `CMD_BOLUS_CANCEL_REQ` (0x2C) → `CMD_BOLUS_CANCEL_RES` (0x8C). Cancels the running immediate bolus.
+ * Criticality: high (delivery command).
+ *
+ * Request wire format (1 byte): `[0] 0x2C` — opcode only, no arguments.
+ *
+ * Response wire format (4 bytes):
+ * ```
+ * [0] 0x8C opcode
+ * [1] resultCode
+ * [2..3] infusedAmount = [2] + [3]/100.0 (U delivered before the cancel took effect)
+ * ```
+ */
+class BolusCancelCommand : BleCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode)
+
+ override fun decode(responsePayload: ByteArray): BolusCancelResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return BolusCancelResponse(
+ resultCode = responsePayload.u(1),
+ infusedAmount = responsePayload.u(2) + responsePayload.u(3) / CENTI
+ )
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x2C
+ const val RESPONSE_OPCODE: Byte = 0x8C.toByte()
+
+ private const val MIN_RESPONSE_LENGTH = 4
+ private const val CENTI = 100.0
+ }
+}
+
+/**
+ * Decoded response from [BolusCancelCommand]: pump [resultCode] (0 = SUCCESS) and the [infusedAmount]
+ * (U) delivered before the cancel took effect.
+ */
+data class BolusCancelResponse(
+ val resultCode: Int,
+ val infusedAmount: Double
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/BuzzModeCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/BuzzModeCommand.kt
new file mode 100644
index 000000000000..b44ec1dd40ad
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/BuzzModeCommand.kt
@@ -0,0 +1,35 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_BUZZ_CHANGE_REQ` (0x18) → `CMD_BUZZ_CHANGE_RES` (0x78). Turns the patch buzzer reminder on/off.
+ *
+ * Request wire format (2 bytes): `[0] 0x18, [1] flag`. **Inverted encoding:** `use=true → 0x01` and
+ * `use=false → 0x00` (the opposite of the naive mapping).
+ *
+ * Response (0x78): `[0] 0x78, [1] resultCode` → [SimpleResultResponse].
+ */
+class BuzzModeCommand(
+ private val use: Boolean
+) : BleCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode, if (use) FLAG_ON else FLAG_OFF)
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x18
+ const val RESPONSE_OPCODE: Byte = 0x78
+ private const val FLAG_ON: Byte = 0x01 // use=true → 0x01 (inverted encoding)
+ private const val FLAG_OFF: Byte = 0x00 // use=false → 0x00
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/CommandCodec.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/CommandCodec.kt
new file mode 100644
index 000000000000..e16c9f44e83a
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/CommandCodec.kt
@@ -0,0 +1,42 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleResponse
+import java.math.BigDecimal
+import java.math.RoundingMode
+import kotlin.math.roundToInt
+
+/**
+ * Shared wire encode/decode helpers for the CareLevo [app.aaps.pump.carelevo.ble.BleCommand]s.
+ */
+
+/** Unsigned byte at [index] as Int. */
+internal fun ByteArray.u(index: Int): Int = this[index].toUByte().toInt()
+
+/**
+ * Encode a unit value as 2 bytes `[intPart, centiPart]`, HALF_UP to 2 dp. Range validation stays at
+ * the command (min/max belongs to the specific op).
+ */
+internal fun encodeUnitCenti(value: Double): ByteArray {
+ // valueOf (canonical decimal via Double.toString), NOT BigDecimal(double) (exact binary
+ // expansion) — the binary form can sit epsilon-below a .xx5 boundary and flip HALF_UP.
+ val rounded = BigDecimal.valueOf(value).setScale(2, RoundingMode.HALF_UP).toDouble()
+ val whole = rounded.toInt()
+ val centi = ((rounded - whole) * 100).roundToInt()
+ return byteArrayOf(whole.toByte(), centi.toByte())
+}
+
+/** Fail fast unless [payload] starts with [opcode] and is at least [minLength] bytes. */
+internal fun requireResponseFrame(payload: ByteArray, opcode: Byte, minLength: Int) {
+ require(payload.isNotEmpty() && payload[0] == opcode) {
+ "expected opcode 0x${"%02X".format(opcode)}, got " +
+ (payload.getOrNull(0)?.let { "0x${"%02X".format(it)}" } ?: "empty")
+ }
+ require(payload.size >= minLength) { "response too short: ${payload.size} < $minLength" }
+}
+
+/**
+ * Response carrying only the pump result code (`data[1]`) — the common 2-byte `cmd,result` reply used by
+ * most write acknowledgements (buzz-mode, cancels, basal-program writes, …). `resultCode` 0 = SUCCESS;
+ * consumers map it.
+ */
+data class SimpleResultResponse(val resultCode: Int) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ExtendBolusCancelCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ExtendBolusCancelCommand.kt
new file mode 100644
index 000000000000..2f573faff500
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ExtendBolusCancelCommand.kt
@@ -0,0 +1,48 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+
+/**
+ * `CMD_EXTEND_BOLUS_CANCEL_REQ` (0x29) → `CMD_EXTEND_BOLUS_CANCEL_RES` (0x89). Cancels a running
+ * extended-bolus infusion program. High criticality (delivery-affecting). Single-response [BleCommand].
+ *
+ * Request wire format (1 byte): `[0] 0x29` — opcode only, no arguments.
+ *
+ * Response wire format (4 bytes):
+ * ```
+ * [0] 0x89 opcode
+ * [1] resultCode 0 = SUCCESS
+ * [2..3] infusedAmount = [2] + [3]/100.0 (U already delivered before the cancel)
+ * ```
+ */
+class ExtendBolusCancelCommand : BleCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode)
+
+ override fun decode(responsePayload: ByteArray): ExtendBolusCancelResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return ExtendBolusCancelResponse(
+ resultCode = responsePayload.u(1),
+ infusedAmount = responsePayload.u(2) + responsePayload.u(3) / CENTI
+ )
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x29
+ const val RESPONSE_OPCODE: Byte = 0x89.toByte()
+
+ private const val MIN_RESPONSE_LENGTH = 4
+ private const val CENTI = 100.0
+ }
+}
+
+/** Decoded response from [ExtendBolusCancelCommand]: pump [resultCode] (0 = SUCCESS) + [infusedAmount] (U). */
+data class ExtendBolusCancelResponse(
+ val resultCode: Int,
+ val infusedAmount: Double
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ExtendBolusCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ExtendBolusCommand.kt
new file mode 100644
index 000000000000..12a8222195ed
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ExtendBolusCommand.kt
@@ -0,0 +1,69 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+
+/**
+ * `CMD_EXTENDED_BOLUS_REQ` (0x25) → `CMD_EXTENDED_BOLUS_RES` (0x85). **Safety-critical delivery** —
+ * starts an extended (dual-wave) bolus: an immediate dose up-front plus an extended portion delivered
+ * at [extendedSpeed] over [hour]h[min]m.
+ *
+ * Request wire format (7 bytes): `[0] 0x25, [1..2] immediateDose = [intPart, centiPart],
+ * [3..4] extendedSpeed = [intPart, centiPart], [5] hour, [6] min`.
+ *
+ * **No dose range validation:** [immediateDose]/[extendedSpeed] are NOT range-checked; only [hour]
+ * (0..24) and [min] (0..59) are validated.
+ *
+ * Response (0x85): `[0] 0x85, [1] resultCode, [2..3] expectedTime = [2]*60 + [3]` (seconds) →
+ * [ExtendBolusResponse].
+ *
+ * (The async 0x9C extended-bolus delay report is a separate unsolicited message — not this response.)
+ */
+class ExtendBolusCommand(
+ private val immediateDose: Double,
+ private val extendedSpeed: Double,
+ private val hour: Int,
+ private val min: Int
+) : BleCommand {
+
+ init {
+ require(hour in HOUR_RANGE) { "hour $hour out of range $HOUR_RANGE" }
+ require(min in MIN_RANGE) { "min $min out of range $MIN_RANGE" }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray =
+ byteArrayOf(requestOpcode) +
+ encodeUnitCenti(immediateDose) +
+ encodeUnitCenti(extendedSpeed) +
+ byteArrayOf(hour.toByte(), min.toByte())
+
+ override fun decode(responsePayload: ByteArray): ExtendBolusResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return ExtendBolusResponse(
+ resultCode = responsePayload.u(1),
+ expectedTimeSeconds = responsePayload.u(2) * SECONDS_PER_MINUTE + responsePayload.u(3)
+ )
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x25
+ const val RESPONSE_OPCODE: Byte = 0x85.toByte()
+ private val HOUR_RANGE = 0..24
+ private val MIN_RANGE = 0..59
+ private const val MIN_RESPONSE_LENGTH = 4
+ private const val SECONDS_PER_MINUTE = 60
+ }
+}
+
+/**
+ * Decoded response from [ExtendBolusCommand]: pump [resultCode] (0 = SUCCESS) and [expectedTimeSeconds],
+ * the pump-reported expected total delivery time in seconds (`[2]*60 + [3]`).
+ */
+data class ExtendBolusResponse(
+ val resultCode: Int,
+ val expectedTimeSeconds: Int
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ImmediateBolusCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ImmediateBolusCommand.kt
new file mode 100644
index 000000000000..dd9a8e49ce9a
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ImmediateBolusCommand.kt
@@ -0,0 +1,122 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+import java.math.BigDecimal
+import java.math.RoundingMode
+import kotlin.math.roundToInt
+
+/**
+ * `CMD_IMMED_BOLUS_REQ` (0x24) → `CMD_IMMED_BOLUS_RES` (0x84).
+ *
+ * **Safety-critical.** Delivers an immediate bolus. The [actionId] is echoed by the
+ * pump at byte 1 of the response and is used by [app.aaps.pump.carelevo.ble.BleClientImpl]
+ * as a second-level correlation guard on top of the opcode match — a response with
+ * the wrong actionId is rejected rather than accepted, which protects against a stale
+ * or mis-routed BOLUS_RES from a previous request being interpreted as the answer to
+ * this one.
+ *
+ * Request wire format (4 bytes):
+ * ```
+ * [0] 0x24 opcode
+ * [1] actionId (1..255) caller-chosen, pump echoes it back in the response
+ * [2] volumeWholeUnits integer part of volume (U, truncated)
+ * [3] volumeCentiUnits fractional part × 100, rounded HALF_UP to 2 dp
+ * ```
+ *
+ * Example: `ImmediateBolusCommand(actionId = 42, volume = 2.5).encode()` →
+ * `[0x24, 0x2A, 0x02, 0x32]` (42 = 0x2A, 50 centi-units = 0x32).
+ *
+ * Response wire format (≥ 8 bytes):
+ * ```
+ * [0] 0x84 opcode
+ * [1] actionId echoed from the request — used for correlation
+ * [2] resultCode pump-specific result code; 0 = SUCCESS
+ * [3] expectedMinutes minutes portion of expected completion time
+ * [4] expectedSeconds seconds portion (combined seconds = [3]*60 + [4])
+ * [5..7] remainsWholeU remaining reservoir units = [5]*100.0 + [6] + [7]/100.0
+ * ```
+ */
+class ImmediateBolusCommand(
+ /** Caller-chosen action identifier in 1..255. Pump echoes this back at byte 1 of the response. */
+ private val actionId: Int,
+ /** Bolus amount in units. Must be > 0. Encoded with 2-decimal precision. */
+ private val volume: Double
+) : BleCommand {
+
+ init {
+ require(actionId in ACTION_ID_MIN..ACTION_ID_MAX) {
+ "actionId must be in $ACTION_ID_MIN..$ACTION_ID_MAX, got $actionId"
+ }
+ require(volume > 0.0) { "volume must be > 0, got $volume" }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+ override val correlationByte: Byte = actionId.toByte()
+
+ override fun encode(): ByteArray {
+ // valueOf (canonical decimal), not BigDecimal(double) — see encodeUnitCenti in CommandCodec.
+ val rounded = BigDecimal.valueOf(volume).setScale(2, RoundingMode.HALF_UP).toDouble()
+ val wholeUnits = rounded.toInt()
+ val centiUnits = ((rounded - wholeUnits) * 100).roundToInt()
+ return byteArrayOf(
+ requestOpcode,
+ actionId.toByte(),
+ wholeUnits.toByte(),
+ centiUnits.toByte()
+ )
+ }
+
+ override fun decode(responsePayload: ByteArray): ImmediateBolusResponse {
+ require(responsePayload.isNotEmpty() && responsePayload[0] == expectedResponseOpcode) {
+ "expected opcode 0x${"%02X".format(expectedResponseOpcode)}, got " +
+ (responsePayload.getOrNull(0)?.let { "0x${"%02X".format(it)}" } ?: "empty")
+ }
+ require(responsePayload.size >= MIN_RESPONSE_LENGTH) {
+ "response too short: ${responsePayload.size} bytes, need at least $MIN_RESPONSE_LENGTH"
+ }
+
+ val actionIdEcho = responsePayload[1].toUByte().toInt()
+ val resultCode = responsePayload[2].toUByte().toInt()
+ val expectedSeconds =
+ responsePayload[3].toUByte().toInt() * SECONDS_PER_MINUTE + responsePayload[4].toUByte().toInt()
+ val remainingUnits = responsePayload[5].toUByte().toInt() * REMAINS_HUNDREDS_SCALE +
+ responsePayload[6].toUByte().toInt() +
+ responsePayload[7].toUByte().toInt() / REMAINS_FRAC_SCALE
+
+ return ImmediateBolusResponse(
+ actionId = actionIdEcho,
+ resultCode = resultCode,
+ expectedCompletionSeconds = expectedSeconds,
+ remainingReservoirUnits = remainingUnits
+ )
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x24
+ const val RESPONSE_OPCODE: Byte = 0x84.toByte()
+
+ const val ACTION_ID_MIN = 1
+ const val ACTION_ID_MAX = 255
+
+ private const val MIN_RESPONSE_LENGTH = 8
+ private const val SECONDS_PER_MINUTE = 60
+ private const val REMAINS_HUNDREDS_SCALE = 100.0
+ private const val REMAINS_FRAC_SCALE = 100.0
+ }
+}
+
+/**
+ * Decoded response from [ImmediateBolusCommand].
+ *
+ * [resultCode] is the raw pump-protocol result byte; consumers map it to a domain
+ * enum (`0 = SUCCESS`).
+ */
+data class ImmediateBolusResponse(
+ val actionId: Int,
+ val resultCode: Int,
+ val expectedCompletionSeconds: Int,
+ val remainingReservoirUnits: Double
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/InfusionInfoCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/InfusionInfoCommand.kt
new file mode 100644
index 000000000000..342f093d962d
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/InfusionInfoCommand.kt
@@ -0,0 +1,94 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+
+/**
+ * `CMD_INFUSION_INFO_REQ` (0x31) → `CMD_INFUSION_INFO_RPT` (0x91). The periodic status read: reservoir,
+ * running time, infused basal/bolus totals, pump state + mode. Single-response [BleCommand].
+ *
+ * Request wire format (2 bytes): `[0] 0x31, [1] inquiryType` (0 = by-request).
+ *
+ * Response wire format (20 bytes):
+ * ```
+ * [0] 0x91 opcode
+ * [1] subId inquiry source code (not persisted)
+ * [2..3] runningMinutes = [2]*60 + [3]
+ * [4..6] insulinRemaining = [4]*100 + [5] + [6]/100.0 (U; the ×100 hundreds byte is a protocol quirk)
+ * [7..8] basal total = [7] + [8]/100.0 (U)
+ * [9..10] bolus total = [9] + [10]/100.0 (U)
+ * [11] pumpState (raw)
+ * [12] mode (raw)
+ * [13..14] infuseSetMinutes = [13]*60 + [14] (not persisted)
+ * [15..16] currentInfusedProgramVolume = [15] + [16]/100.0 (not persisted)
+ * [17..19] realInfusedTime = ([17]*60 + [18])*60 + [19] (seconds; not persisted)
+ * ```
+ * Decodes RAW values (unsigned). The pumpState/mode normalization to the persisted codes (the
+ * int→enum→int roundtrip) happens at the state-apply layer (`CarelevoPatch.applyInfusionInfoReport`),
+ * keeping this command a pure wire decoder.
+ */
+class InfusionInfoCommand(
+ private val inquiryType: Int = DEFAULT_INQUIRY_TYPE
+) : BleCommand {
+
+ init {
+ require(inquiryType in 0..1) { "inquiryType must be 0 or 1, got $inquiryType" }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode, inquiryType.toByte())
+
+ override fun decode(responsePayload: ByteArray): InfusionInfoResponse {
+ require(responsePayload.isNotEmpty() && responsePayload[0] == expectedResponseOpcode) {
+ "expected opcode 0x${"%02X".format(expectedResponseOpcode)}, got " +
+ (responsePayload.getOrNull(0)?.let { "0x${"%02X".format(it)}" } ?: "empty")
+ }
+ require(responsePayload.size >= MIN_RESPONSE_LENGTH) {
+ "response too short: ${responsePayload.size} < $MIN_RESPONSE_LENGTH"
+ }
+ fun u(i: Int) = responsePayload[i].toUByte().toInt()
+ return InfusionInfoResponse(
+ subId = u(1),
+ runningMinutes = u(2) * MINUTES_PER_HOUR + u(3),
+ insulinRemaining = u(4) * HUNDRED + u(5) + u(6) / CENTI,
+ infusedTotalBasalAmount = u(7) + u(8) / CENTI,
+ infusedTotalBolusAmount = u(9) + u(10) / CENTI,
+ pumpStateRaw = u(11),
+ modeRaw = u(12),
+ currentInfusedProgramVolume = u(15) + u(16) / CENTI,
+ realInfusedTime = (u(17) * MINUTES_PER_HOUR + u(18)) * SECONDS_PER_MINUTE + u(19)
+ )
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x31
+ const val RESPONSE_OPCODE: Byte = 0x91.toByte()
+ const val DEFAULT_INQUIRY_TYPE = 0
+
+ private const val MIN_RESPONSE_LENGTH = 20
+ private const val MINUTES_PER_HOUR = 60
+ private const val SECONDS_PER_MINUTE = 60
+ private const val HUNDRED = 100
+ private const val CENTI = 100.0
+ }
+}
+
+/**
+ * Decoded response from [InfusionInfoCommand] — RAW wire values. [pumpStateRaw]/[modeRaw] are the
+ * unnormalized bytes; `CarelevoPatch.applyInfusionInfoReport` applies the enum roundtrip before
+ * persisting. [currentInfusedProgramVolume]/[realInfusedTime]/[subId] are decoded but not persisted.
+ */
+data class InfusionInfoResponse(
+ val subId: Int,
+ val runningMinutes: Int,
+ val insulinRemaining: Double,
+ val infusedTotalBasalAmount: Double,
+ val infusedTotalBolusAmount: Double,
+ val pumpStateRaw: Int,
+ val modeRaw: Int,
+ val currentInfusedProgramVolume: Double,
+ val realInfusedTime: Int
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/InfusionThresholdCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/InfusionThresholdCommand.kt
new file mode 100644
index 000000000000..06c962d4d2e3
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/InfusionThresholdCommand.kt
@@ -0,0 +1,54 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+
+/**
+ * `CMD_INFUSION_THRESHOLD_REQ` (0x17) → `CMD_INFUSION_THRESHOLD_RES` (0x77). Sets an infusion limit —
+ * one command class for both consumers, parameterized by [isMaxVolume]:
+ * - `false` = max basal **speed** (U/h), range 0.05..15.0 — flag byte 0x00
+ * - `true` = max bolus **volume** (U), range 0.05..25.0 — flag byte 0x01
+ *
+ * The flag byte is inverted: `flag = if (isMaxVolume) 0x01 else 0x00`.
+ *
+ * Request wire format (4 bytes): `[0] 0x17, [1] flag, [2..3] value = [intPart, centiPart]`.
+ * Response (0x77): `[0] 0x77, [1] type, [2] resultCode`.
+ */
+class InfusionThresholdCommand(
+ private val isMaxVolume: Boolean,
+ private val value: Double
+) : BleCommand {
+
+ init {
+ val range = if (isMaxVolume) MAX_VOLUME_RANGE else MAX_SPEED_RANGE
+ require(value in range) { "value $value out of range $range (isMaxVolume=$isMaxVolume)" }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray =
+ byteArrayOf(requestOpcode, if (isMaxVolume) FLAG_MAX_VOLUME else FLAG_MAX_SPEED) + encodeUnitCenti(value)
+
+ override fun decode(responsePayload: ByteArray): InfusionThresholdResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return InfusionThresholdResponse(type = responsePayload.u(1), resultCode = responsePayload.u(2))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x17
+ const val RESPONSE_OPCODE: Byte = 0x77
+ private const val FLAG_MAX_SPEED: Byte = 0x00
+ private const val FLAG_MAX_VOLUME: Byte = 0x01
+ private val MAX_SPEED_RANGE = 0.05..15.0
+ private val MAX_VOLUME_RANGE = 0.05..25.0
+ private const val MIN_RESPONSE_LENGTH = 3
+ }
+}
+
+/** Decoded response from [InfusionThresholdCommand]: echoed [type] flag + pump [resultCode] (0 = SUCCESS). */
+data class InfusionThresholdResponse(
+ val type: Int,
+ val resultCode: Int
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/MacAddressCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/MacAddressCommand.kt
new file mode 100644
index 000000000000..2cb9185e9c38
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/MacAddressCommand.kt
@@ -0,0 +1,72 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+
+/**
+ * `CMD_MAC_ADDR_REQ` (0x3B) → `CMD_MAC_ADDR_RES` (0x9B).
+ *
+ * Reads the peripheral's MAC address during initial bonding. Read-only, no pump state change.
+ *
+ * Request wire format (2 bytes):
+ * ```
+ * [0] 0x3B opcode
+ * [1] key caller-chosen random key, echoed in the response checksum calc
+ * ```
+ *
+ * Response wire format (≥ 7 bytes):
+ * ```
+ * [0] 0x9B opcode
+ * [1..6] macAddress 6 bytes, most-significant byte first
+ * [7..] checkSum remainder of the payload, derived from (address || key)
+ * ```
+ */
+class MacAddressCommand(
+ /** Random byte chosen by the caller; the response's checksum is derived from this + the address. */
+ private val key: Byte
+) : BleCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode, key)
+
+ override fun decode(responsePayload: ByteArray): MacAddressResponse {
+ require(responsePayload.isNotEmpty() && responsePayload[0] == expectedResponseOpcode) {
+ "expected opcode 0x${"%02X".format(expectedResponseOpcode)}, got " +
+ (responsePayload.getOrNull(0)?.let { "0x${"%02X".format(it)}" } ?: "empty")
+ }
+ require(responsePayload.size >= MIN_LENGTH) {
+ "response too short: ${responsePayload.size} bytes, need at least $MIN_LENGTH"
+ }
+
+ val macHex = responsePayload.copyOfRange(ADDRESS_START, ADDRESS_END).toUppercaseHex()
+ val checkSumHex = responsePayload.copyOfRange(CHECKSUM_START, responsePayload.size).toUppercaseHex()
+ return MacAddressResponse(macAddress = macHex, checkSum = checkSumHex)
+ }
+
+ private fun ByteArray.toUppercaseHex(): String =
+ joinToString(separator = "") { "%02X".format(it) }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x3B
+ const val RESPONSE_OPCODE: Byte = 0x9B.toByte()
+
+ private const val ADDRESS_START = 1
+ private const val ADDRESS_END = 7 // exclusive — bytes 1..6 inclusive
+ private const val CHECKSUM_START = 7
+ private const val MIN_LENGTH = CHECKSUM_START + 1 // opcode + 6 address bytes + ≥1 checksum byte
+ }
+}
+
+/**
+ * Decoded response from [MacAddressCommand].
+ *
+ * Both fields are upper-case hex strings with no separators (e.g. `"94B2161D2F6D"`).
+ * The consumer is responsible for any display formatting.
+ */
+data class MacAddressResponse(
+ val macAddress: String,
+ val checkSum: String
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/NeedleAckCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/NeedleAckCommand.kt
new file mode 100644
index 000000000000..e7657c0ded21
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/NeedleAckCommand.kt
@@ -0,0 +1,38 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_NEEDLE_INSERT_ACK` (0x19) → `CMD_CANNULA_INSERTION_RPT_ACK_RES` (0x7A). Confirms the cannula
+ * insertion result back to the patch.
+ *
+ * Request wire format (2 bytes): `[0] 0x19, [1] flag`, where `isSuccess=true → 0x00`,
+ * `isSuccess=false → 0x01`.
+ *
+ * **Behavioral note:** this command awaits the 0x7A response. Confirm on hardware that the pump actually
+ * sends 0x7A before relying on the awaited result. Response (0x7A): `[0] 0x7A, [1] resultCode` →
+ * [SimpleResultResponse].
+ */
+class NeedleAckCommand(
+ private val isSuccess: Boolean
+) : BleCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode, if (isSuccess) FLAG_SUCCESS else FLAG_FAILURE)
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x19
+ const val RESPONSE_OPCODE: Byte = 0x7A
+ private const val FLAG_SUCCESS: Byte = 0x00
+ private const val FLAG_FAILURE: Byte = 0x01
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/NeedleStatusCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/NeedleStatusCommand.kt
new file mode 100644
index 000000000000..a99edf83e007
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/NeedleStatusCommand.kt
@@ -0,0 +1,34 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_NEEDLE_STATUS_REQ` (0x1A) → `CMD_NEEDLE_INSERT_RPT` (0x79). Requests the cannula-insertion status.
+ *
+ * **Asymmetric opcodes** (0x1A → 0x79, not the usual `+0x60`) and a **long physical wait**: the pump
+ * replies only once the needle insertion has finished, with no fixed timeout on the wire. The caller
+ * must therefore wrap `request(...)` in a generous `withTimeout(...)`.
+ *
+ * Request wire format (2 bytes): `[0] 0x1A, [1] 0x00`.
+ * Response (0x79): `[0] 0x79, [1] resultCode` → [SimpleResultResponse].
+ */
+class NeedleStatusCommand : BleCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode, REQUEST_FLAG)
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x1A
+ const val RESPONSE_OPCODE: Byte = 0x79
+ private const val REQUEST_FLAG: Byte = 0x00
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/NoticeThresholdCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/NoticeThresholdCommand.kt
new file mode 100644
index 000000000000..ffb88d21e3af
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/NoticeThresholdCommand.kt
@@ -0,0 +1,58 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+
+/**
+ * `CMD_NOTICE_THRESHOLD_REQ` (0x15) → `CMD_NOTICE_THRESHOLD_RES` (0x75). Sets a reminder threshold —
+ * one command class for both consumers, parameterized by [thresholdType]:
+ * - [TYPE_LOW_INSULIN] (0): low-insulin reminder amount (value range 20..50 U)
+ * - [TYPE_EXPIRY] (1): patch-expiry reminder hours (value range 24..167)
+ *
+ * Request wire format (3 bytes): `[0] 0x15, [1] thresholdType, [2] value`.
+ *
+ * Response (0x75): `[0] 0x75, [1] thresholdType` — no result code is carried on the wire, so arrival of
+ * the frame is the success signal; [resultCode] is always reported as 0.
+ */
+class NoticeThresholdCommand(
+ private val thresholdType: Int,
+ private val value: Int
+) : BleCommand {
+
+ init {
+ require(thresholdType == TYPE_LOW_INSULIN || thresholdType == TYPE_EXPIRY) {
+ "thresholdType must be $TYPE_LOW_INSULIN or $TYPE_EXPIRY, got $thresholdType"
+ }
+ val range = if (thresholdType == TYPE_EXPIRY) EXPIRY_RANGE else LOW_INSULIN_RANGE
+ require(value in range) { "value $value out of range $range for type $thresholdType" }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode, thresholdType.toByte(), value.toByte())
+
+ override fun decode(responsePayload: ByteArray): NoticeThresholdResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return NoticeThresholdResponse(thresholdType = responsePayload.u(1), resultCode = FABRICATED_RESULT)
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x15
+ const val RESPONSE_OPCODE: Byte = 0x75
+ const val TYPE_LOW_INSULIN = 0
+ const val TYPE_EXPIRY = 1
+
+ private val LOW_INSULIN_RANGE = 20..50
+ private val EXPIRY_RANGE = 24..167
+ private const val MIN_RESPONSE_LENGTH = 2
+ private const val FABRICATED_RESULT = 0 // no result code on the wire; frame arrival = success
+ }
+}
+
+/** Decoded response from [NoticeThresholdCommand]: the echoed [thresholdType]; [resultCode] is always 0 (see command). */
+data class NoticeThresholdResponse(
+ val thresholdType: Int,
+ val resultCode: Int
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PatchDiscardCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PatchDiscardCommand.kt
new file mode 100644
index 000000000000..306387aa9856
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PatchDiscardCommand.kt
@@ -0,0 +1,31 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_PATCH_DISCARD_REQ` (0x36) → `CMD_PATCH_DISCARD_RES` (0x96). Discards (deactivates) the patch.
+ * Medium-criticality write with no arguments — sends only the opcode byte.
+ *
+ * Request wire format (1 byte): `[0] 0x36`.
+ * Response (0x96): `[0] 0x96, [1] resultCode` → [SimpleResultResponse] (0 = SUCCESS). Any timestamp/cmd
+ * bookkeeping is not on the wire; this decoder keeps only the result byte.
+ */
+class PatchDiscardCommand : BleCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode)
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x36
+ const val RESPONSE_OPCODE: Byte = 0x96.toByte()
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PatchInfoCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PatchInfoCommand.kt
new file mode 100644
index 000000000000..d7e66756b705
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PatchInfoCommand.kt
@@ -0,0 +1,98 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleMultiCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+
+/**
+ * `CMD_PATCH_INFO_REQ` (0x33) → the patch answers with TWO report frames: RPT1 (0x93, serial) +
+ * RPT2 (0x94, firmware/model). A [BleMultiCommand]: one write, both notifications collected (any
+ * order) before [decode].
+ *
+ * Request wire format (1 byte): `[0] 0x33` — no args, no framing.
+ *
+ * RPT1 (0x93) wire format (≥ 15 bytes):
+ * ```
+ * [0] 0x93 opcode
+ * [1] resultCode
+ * [2..14] serialNumber 13 chars (each byte → ASCII char)
+ * ```
+ * RPT2 (0x94) wire format (real frame is 16 bytes, indices 0..15):
+ * ```
+ * [0] 0x94 opcode
+ * [1] resultCode
+ * [2..5] firmwareVersion 4 chars (each byte → ASCII char)
+ * [11..15] modelName decimal-int string of each present byte (byte 10 is skipped; byte 16 is
+ * out of range in the 16-byte frame)
+ * ```
+ * **Two protocol quirks:** `modelName` uses each byte's decimal value (not ASCII) and skips byte 10.
+ * `bootDateTime` is NOT on the wire at all — the persistence layer stamps it from the phone clock — so
+ * that mapping stays at the persistence layer, not here; this command decodes only wire bytes.
+ */
+class PatchInfoCommand : BleMultiCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcodes: Set = setOf(RPT1_OPCODE, RPT2_OPCODE)
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode)
+
+ override fun decode(responses: Map): PatchInfoResponse {
+ val rpt1 = requireNotNull(responses[RPT1_OPCODE]) { "missing RPT1 (0x93)" }
+ val rpt2 = requireNotNull(responses[RPT2_OPCODE]) { "missing RPT2 (0x94)" }
+ require(rpt1.size >= RPT1_MIN_LENGTH) { "RPT1 too short: ${rpt1.size} < $RPT1_MIN_LENGTH" }
+ require(rpt2.size >= RPT2_MIN_LENGTH) { "RPT2 too short: ${rpt2.size} < $RPT2_MIN_LENGTH" }
+
+ // modelName is best-effort over bytes 11..16: the real 0x94 frame is 16 bytes (indices 0..15)
+ // so byte 16 is absent — clamp to the frame end (a 16-byte frame → model bytes 11..15).
+ val modelName =
+ if (MODEL_START <= rpt2.lastIndex) rpt2.decimalString(MODEL_START, minOf(MODEL_END, rpt2.lastIndex))
+ else ""
+
+ return PatchInfoResponse(
+ serialResultCode = rpt1[1].toUByte().toInt(),
+ serialNumber = rpt1.asciiString(SERIAL_START, SERIAL_END),
+ detailResultCode = rpt2[1].toUByte().toInt(),
+ firmwareVersion = rpt2.asciiString(FIRMWARE_START, FIRMWARE_END),
+ modelName = modelName
+ )
+ }
+
+ /** Bytes [startInclusive]..[endInclusive] as ASCII, each byte → one char. */
+ private fun ByteArray.asciiString(startInclusive: Int, endInclusive: Int): String =
+ (startInclusive..endInclusive).joinToString("") { this[it].toUByte().toInt().toChar().toString() }
+
+ /** Bytes [startInclusive]..[endInclusive] as the concatenation of each byte's DECIMAL value (protocol quirk). */
+ private fun ByteArray.decimalString(startInclusive: Int, endInclusive: Int): String =
+ (startInclusive..endInclusive).joinToString("") { this[it].toUByte().toInt().toString() }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x33
+ const val RPT1_OPCODE: Byte = 0x93.toByte()
+ const val RPT2_OPCODE: Byte = 0x94.toByte()
+
+ private const val SERIAL_START = 2
+ private const val SERIAL_END = 14 // bytes 2..14 = 13 chars
+ private const val FIRMWARE_START = 2
+ private const val FIRMWARE_END = 5 // bytes 2..5 = 4 chars
+ private const val MODEL_START = 11
+ private const val MODEL_END = 16 // bytes 11..16 (byte 10 skipped)
+
+ private const val RPT1_MIN_LENGTH = SERIAL_END + 1 // 15 — full serial required
+ private const val RPT2_MIN_LENGTH = FIRMWARE_END + 1 // 6 — firmware required; modelName is best-effort (see decode)
+ }
+}
+
+/**
+ * Decoded response from [PatchInfoCommand] — the wire content of RPT1 (0x93) + RPT2 (0x94).
+ *
+ * [serialResultCode]/[detailResultCode] are the raw pump result bytes (0 = SUCCESS). `bootDateTime` is
+ * intentionally absent — it is not carried on the wire; the persistence layer stamps it from the phone
+ * clock.
+ */
+data class PatchInfoResponse(
+ val serialResultCode: Int,
+ val serialNumber: String,
+ val detailResultCode: Int,
+ val firmwareVersion: String,
+ val modelName: String
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PumpResumeCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PumpResumeCommand.kt
new file mode 100644
index 000000000000..c1757c1f8963
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PumpResumeCommand.kt
@@ -0,0 +1,72 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleResponse
+
+/**
+ * `CMD_PUMP_RESTART_REQ` (0x27) → `CMD_PUMP_RESTART_RES` (0x87). Resumes (restarts) a paused pump —
+ * **SAFETY-CRITICAL** delivery-affecting operation.
+ *
+ * Request wire format (3 bytes): `[0] 0x27, [1] mode, [2] subId`.
+ * - `mode` — range-checked 1..4, emitted as one raw byte (`mode.toByte()`).
+ * - `subId` — only 0, 1 or 4 are valid and each maps to itself (4→0x04, 1→0x01, else→0x00); any other
+ * value is rejected.
+ *
+ * Response (0x87): `[0] 0x87, [1] resultCode, [2] mode, [3] subId`. **`subId` is OPTIONAL** — `data[3]`
+ * is read only when the response is longer than 3 bytes, otherwise `subId` defaults to 0 (variable-length
+ * reply). Any timestamp/cmd bookkeeping is not on the wire and is dropped by this pure wire decoder. (The
+ * separate 0x88 `BasalRestartRpt` is async and is **not** this response.)
+ */
+class PumpResumeCommand(
+ private val mode: Int,
+ private val subId: Int
+) : BleCommand {
+
+ init {
+ require(mode in MODE_RANGE) { "mode $mode out of range $MODE_RANGE" }
+ require(subId in VALID_SUB_IDS) { "subId $subId invalid, must be one of $VALID_SUB_IDS" }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode, mode.toByte(), encodeSubId(subId))
+
+ override fun decode(responsePayload: ByteArray): PumpResumeResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return PumpResumeResponse(
+ resultCode = responsePayload.u(1),
+ mode = responsePayload.u(2),
+ // subId is optional: only present when the reply carries a 4th byte, else 0.
+ subId = if (responsePayload.size > SUB_ID_INDEX) responsePayload.u(SUB_ID_INDEX) else 0
+ )
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x27
+ const val RESPONSE_OPCODE: Byte = 0x87.toByte()
+
+ private val MODE_RANGE = 1..4
+ private val VALID_SUB_IDS = setOf(0, 1, 4)
+ private const val SUB_ID_INDEX = 3
+ private const val MIN_RESPONSE_LENGTH = 3
+
+ /** Encodes subId: 4→0x04, 1→0x01, else→0x00 (identity for valid ids). */
+ private fun encodeSubId(subId: Int): Byte = when (subId) {
+ 4 -> 0x04
+ 1 -> 0x01
+ else -> 0x00
+ }
+ }
+}
+
+/**
+ * Decoded response from [PumpResumeCommand]: pump [resultCode] (0 = SUCCESS), echoed [mode], and echoed
+ * [subId] (0 when the reply omits the optional 4th byte).
+ */
+data class PumpResumeResponse(
+ val resultCode: Int,
+ val mode: Int,
+ val subId: Int
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PumpStopCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PumpStopCommand.kt
new file mode 100644
index 000000000000..5ed23e0d90b8
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/PumpStopCommand.kt
@@ -0,0 +1,61 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_PUMP_STOP_REQ` (0x26) → `CMD_PUMP_STOP_RES` (0x86). **SAFETY-CRITICAL** — suspends (stops) insulin
+ * delivery for [durationMinutes], answered with a result-only acknowledgement.
+ *
+ * The later `CMD_PUMP_STOP_RPT` (0x8A) the pump pushes when the stop period ends is an async/unsolicited
+ * report — **not** this command's response; it is handled via [app.aaps.pump.carelevo.ble.BleClient.unsolicitedEvents].
+ *
+ * Request wire format (4 bytes), splitting the duration into hours+minutes:
+ * ```
+ * [0] 0x26 opcode
+ * [1] durationMinutes / 60 hours — range 0..5
+ * [2] durationMinutes % 60 minutes — range 0..60
+ * [3] subId source — range 0..1
+ * ```
+ * Each field is one raw byte (`value.toByte()`), range-checked as above. Because `durationMinutes % 60`
+ * is always 0..59 for a non-negative duration, the effective span is `0..359` minutes (5 h 59 min).
+ *
+ * Response (0x86): `[0] 0x86, [1] resultCode` → [SimpleResultResponse]. Any timestamp/cmd bookkeeping is
+ * not on the wire, so this pure wire decoder drops it (the caller owns timestamping).
+ */
+class PumpStopCommand(
+ private val durationMinutes: Int,
+ private val subId: Int
+) : BleCommand {
+
+ private val hours = durationMinutes / MINUTES_PER_HOUR
+ private val minutes = durationMinutes % MINUTES_PER_HOUR
+
+ init {
+ require(hours in HOURS_RANGE) { "durationMinutes $durationMinutes → hours $hours out of range $HOURS_RANGE" }
+ require(minutes in MINUTES_RANGE) { "durationMinutes $durationMinutes → minutes $minutes out of range $MINUTES_RANGE" }
+ require(subId in SUB_ID_RANGE) { "subId $subId out of range $SUB_ID_RANGE" }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray =
+ byteArrayOf(requestOpcode, hours.toByte(), minutes.toByte(), subId.toByte())
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x26
+ const val RESPONSE_OPCODE: Byte = 0x86.toByte()
+
+ private const val MINUTES_PER_HOUR = 60
+ private val HOURS_RANGE = 0..5
+ private val MINUTES_RANGE = 0..60
+ private val SUB_ID_RANGE = 0..1
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/SafetyCheckCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/SafetyCheckCommand.kt
new file mode 100644
index 000000000000..895fcb99ec7a
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/SafetyCheckCommand.kt
@@ -0,0 +1,74 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleResponse
+import app.aaps.pump.carelevo.ble.BleStreamCommand
+
+/**
+ * `CMD_SAFETY_CHECK_REQ` (0x12) → `CMD_SAFETY_CHECK_RES` (0x72). The activation safety check: the pump
+ * primes/checks and streams progress reports (`REP_REQUEST`/`REP_REQUEST1`) then a terminal SUCCESS/error.
+ * This is the CareLevo [BleStreamCommand] — collected until [isTerminal].
+ *
+ * Request wire format (1 byte): `[0] 0x12`.
+ *
+ * Response wire format (0x72, ≥ 4 bytes):
+ * ```
+ * [0] 0x72 opcode
+ * [1] resultCode (SafetyCheckResult: 0 SUCCESS, 4/18 progress, 1/2/3/11/12 errors)
+ * [2..3] insulinVolume = [2]*100 + [3] (U; ×100 hundreds-byte quirk, no decimal byte)
+ * [4..5] durationSeconds = [4]*60 + [5] — only if size > 4; else the 210 s fallback
+ * ```
+ * [isTerminal] is `true` for any non-progress result (SUCCESS **or** an error code), so the stream
+ * completes with the terminal frame rather than timing out; the consumer maps [SafetyCheckResponse.resultCode]
+ * to SUCCESS vs error.
+ */
+class SafetyCheckCommand : BleStreamCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode)
+
+ override fun decode(responsePayload: ByteArray): SafetyCheckResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ // Duration bytes are read only when size > 4; a short/progress frame falls back to 210 s.
+ // Real frames are size 4 or ≥ 6.
+ val durationSeconds =
+ if (responsePayload.size > 4) responsePayload.u(4) * SECONDS_PER_MINUTE + responsePayload.u(5)
+ else DEFAULT_DURATION_SECONDS
+ return SafetyCheckResponse(
+ resultCode = responsePayload.u(1),
+ insulinVolume = responsePayload.u(2) * HUNDRED + responsePayload.u(3),
+ durationSeconds = durationSeconds
+ )
+ }
+
+ override fun isTerminal(response: SafetyCheckResponse): Boolean =
+ response.resultCode != REP_REQUEST && response.resultCode != REP_REQUEST1
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x12
+ const val RESPONSE_OPCODE: Byte = 0x72
+
+ // SafetyCheckResult codes (see CarelevoBtEnums).
+ const val RESULT_SUCCESS = 0
+ const val REP_REQUEST = 4 // progress
+ const val REP_REQUEST1 = 18 // progress
+
+ private const val MIN_RESPONSE_LENGTH = 4
+ private const val DEFAULT_DURATION_SECONDS = 210
+ private const val SECONDS_PER_MINUTE = 60
+ private const val HUNDRED = 100
+ }
+}
+
+/**
+ * A single streamed safety-check frame: [resultCode] (progress `REP_REQUEST`/`REP_REQUEST1`, terminal
+ * `RESULT_SUCCESS`, or an error code), remaining [insulinVolume] (U), and the [durationSeconds] the pump
+ * expects the check to take (drives the UI countdown).
+ */
+data class SafetyCheckResponse(
+ val resultCode: Int,
+ val insulinVolume: Int,
+ val durationSeconds: Int
+) : BleResponse
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/SetTimeCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/SetTimeCommand.kt
new file mode 100644
index 000000000000..d2ef8a601888
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/SetTimeCommand.kt
@@ -0,0 +1,87 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.BleMultiCommand
+import org.joda.time.DateTime
+
+/**
+ * Shared `CMD_SET_TIME_REQ` (0x11) request encoding:
+ * `[0] 0x11, [1] subId, [2..7] dateTime = [yy,MM,dd,HH,mm,ss], [8..9] volume = [vol/100, vol%100], [10] aidMode]`.
+ *
+ * [dateTime] is an explicit parameter (caller passes `DateTime.now()`) so `encode()` is deterministic and
+ * unit-testable. Year = last two digits (`year % 100`); volume validated 0..300.
+ */
+internal fun encodeSetTime(subId: Int, volume: Int, aidMode: Int, dateTime: DateTime): ByteArray {
+ require(volume in VOLUME_RANGE) { "volume out of range $VOLUME_RANGE" }
+ // last two digits via arithmetic — can't throw on unusual years.
+ val yy = dateTime.year % 100
+ return byteArrayOf(
+ SET_TIME_REQUEST_OPCODE,
+ subId.toByte(),
+ yy.toByte(),
+ dateTime.monthOfYear.toByte(),
+ dateTime.dayOfMonth.toByte(),
+ dateTime.hourOfDay.toByte(),
+ dateTime.minuteOfHour.toByte(),
+ dateTime.secondOfMinute.toByte(),
+ (volume / HUNDRED).toByte(),
+ (volume % HUNDRED).toByte(),
+ aidMode.toByte()
+ )
+}
+
+internal const val SET_TIME_REQUEST_OPCODE: Byte = 0x11
+private val VOLUME_RANGE = 0..300
+private const val HUNDRED = 100
+
+/**
+ * `CMD_SET_TIME_REQ` (0x11) → `CMD_SET_TIME_RES` (0x71). Sets the patch clock — the normal path (e.g. the
+ * timezone/DST update, subId=1). Response is result-only → [SimpleResultResponse].
+ *
+ * NOTE the dual shape of 0x11: during **activation** the same write is used with subId=0 to make the patch
+ * emit its info reports (0x93+0x94) and 0x71 is ignored — that path is [SetTimeForPatchInfoCommand].
+ */
+class SetTimeCommand(
+ private val subId: Int,
+ private val volume: Int,
+ private val aidMode: Int,
+ private val dateTime: DateTime
+) : BleCommand {
+
+ override val requestOpcode: Byte = SET_TIME_REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = encodeSetTime(subId, volume, aidMode, dateTime)
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val RESPONSE_OPCODE: Byte = 0x71
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
+
+/**
+ * `CMD_SET_TIME_REQ` (0x11) → RPT1 (0x93) + RPT2 (0x94). The **activation** variant of set-time (subId=0):
+ * the same 0x11 write triggers the patch to emit its two info reports, which this collects as a
+ * [BleMultiCommand] and decodes into a [PatchInfoResponse] (reusing [PatchInfoCommand]'s wire decode).
+ * The 0x71 set-time ack is ignored on this path — see [SetTimeCommand] for the normal shape.
+ */
+class SetTimeForPatchInfoCommand(
+ private val subId: Int,
+ private val volume: Int,
+ private val aidMode: Int,
+ private val dateTime: DateTime
+) : BleMultiCommand {
+
+ override val requestOpcode: Byte = SET_TIME_REQUEST_OPCODE
+ override val expectedResponseOpcodes: Set = setOf(PatchInfoCommand.RPT1_OPCODE, PatchInfoCommand.RPT2_OPCODE)
+
+ override fun encode(): ByteArray = encodeSetTime(subId, volume, aidMode, dateTime)
+
+ override fun decode(responses: Map): PatchInfoResponse = PatchInfoCommand().decode(responses)
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/TempBasalCancelCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/TempBasalCancelCommand.kt
new file mode 100644
index 000000000000..c5f0bbc20eea
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/TempBasalCancelCommand.kt
@@ -0,0 +1,32 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_TEMP_BASAL_CANCEL_REQ` (0x2D) → `CMD_TEMP_BASAL_CANCEL_RES` (0x8D). Cancels a running temp-basal
+ * program. Criticality: high (a delivery-control command).
+ *
+ * Request wire format (1 byte): `[0] 0x2D` — no arguments, so the opcode is the whole frame.
+ *
+ * Response (0x8D): `[0] 0x8D, [1] resultCode` → [SimpleResultResponse] (`resultCode` 0 = SUCCESS). The
+ * wire reply is result-only.
+ */
+class TempBasalCancelCommand : BleCommand {
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray = byteArrayOf(requestOpcode)
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x2D
+ const val RESPONSE_OPCODE: Byte = 0x8D.toByte()
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/TempBasalCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/TempBasalCommand.kt
new file mode 100644
index 000000000000..bdab8d3501a5
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/TempBasalCommand.kt
@@ -0,0 +1,89 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_TEMP_BASAL_REQ` (0x23) → `CMD_TEMP_BASAL_RES` (0x83). Starts a temp basal — **safety-critical
+ * delivery**. One command class for both modes, parameterized by [Mode]:
+ * - [Mode.BY_UNIT] — an absolute rate in U/h.
+ * - [Mode.BY_PERCENT] — a percentage of the scheduled basal.
+ *
+ * **The ByUnit↔ByPercent ASYMMETRY must be exact** (a wrong byte here is a patient-safety bug):
+ * ```
+ * BY_UNIT (6 bytes): [0] 0x23, [1..2] unit = [intPart, centiPart], [3] hour, [4] min, [5] 0x00
+ * BY_PERCENT (5 bytes): [0] 0x23, [1..2] value = [intPart, centiPart], [3] hour, [4] min
+ * ```
+ * Wire-format quirks:
+ * - **ByUnit trailing 0x00:** BY_UNIT appends a sixth `0x00` byte; BY_PERCENT appends **nothing**
+ * (the asymmetry).
+ * - **ByPercent `/100.0`:** [byPercent] encodes `infusionPercent / 100.0` (e.g. 150 % → `1.50` →
+ * `[1, 50]`) before [encodeUnitCenti].
+ * - **ByUnit has NO value-range check:** any `infusionUnit` is accepted on the wire. ByPercent
+ * validates the divided value, so `percent/100.0` must be in `0.0..200.0`.
+ * - hour is range-checked 0..24, minute 0..59 — same ranges for both modes.
+ *
+ * Response (0x83): `[0] 0x83, [1] resultCode` → [SimpleResultResponse] (0 = SUCCESS). The wire reply is
+ * result-only.
+ */
+class TempBasalCommand private constructor(
+ private val mode: Mode,
+ private val value: Double,
+ private val hour: Int,
+ private val minute: Int
+) : BleCommand {
+
+ /** Which of the two 0x23 variants this instance encodes. Use [byUnit] / [byPercent] to build. */
+ enum class Mode { BY_UNIT, BY_PERCENT }
+
+ init {
+ require(hour in HOUR_RANGE) { "hour $hour out of range $HOUR_RANGE" }
+ require(minute in MINUTE_RANGE) { "minute $minute out of range $MINUTE_RANGE" }
+ // BY_UNIT has no value-range check on the wire.
+ if (mode == Mode.BY_PERCENT) {
+ require(value in PERCENT_VALUE_RANGE) { "percent/100.0 = $value out of range $PERCENT_VALUE_RANGE" }
+ }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray {
+ val head = byteArrayOf(requestOpcode) + encodeUnitCenti(value) + byteArrayOf(hour.toByte(), minute.toByte())
+ return when (mode) {
+ Mode.BY_UNIT -> head + byteArrayOf(TRAILING_BOOL_TRUE) // BY_UNIT trailing byte = 0x00
+ Mode.BY_PERCENT -> head // no trailing byte (the asymmetry)
+ }
+ }
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x23
+ const val RESPONSE_OPCODE: Byte = 0x83.toByte()
+
+ private const val TRAILING_BOOL_TRUE: Byte = 0x00 // BY_UNIT trailing byte
+ private val HOUR_RANGE = 0..24
+ private val MINUTE_RANGE = 0..59
+ private val PERCENT_VALUE_RANGE = 0.0..200.0
+ private const val MIN_RESPONSE_LENGTH = 2
+
+ /**
+ * ByUnit variant — absolute temp basal rate [infusionUnit] (U/h) for [infusionHour]:[infusionMin].
+ * No range check on [infusionUnit]. Encodes the 6-byte frame with the trailing 0x00.
+ */
+ fun byUnit(infusionUnit: Double, infusionHour: Int, infusionMin: Int): TempBasalCommand =
+ TempBasalCommand(Mode.BY_UNIT, infusionUnit, infusionHour, infusionMin)
+
+ /**
+ * ByPercent variant — [infusionPercent] percent of scheduled basal for [infusionHour]:[infusionMin].
+ * Encodes `infusionPercent / 100.0` (so 100 → `1.00`); that divided value must be in `0.0..200.0`.
+ * Encodes the 5-byte frame (no trailing byte).
+ */
+ fun byPercent(infusionPercent: Int, infusionHour: Int, infusionMin: Int): TempBasalCommand =
+ TempBasalCommand(Mode.BY_PERCENT, infusionPercent.toDouble() / 100.0, infusionHour, infusionMin)
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ThresholdSetupCommand.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ThresholdSetupCommand.kt
new file mode 100644
index 000000000000..d15e6e9bdaec
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/commands/ThresholdSetupCommand.kt
@@ -0,0 +1,65 @@
+package app.aaps.pump.carelevo.ble.commands
+
+import app.aaps.pump.carelevo.ble.BleCommand
+
+/**
+ * `CMD_THRESHOLD_SETUP_REQ` (0x1B) → `CMD_THRESHOLD_SETUP_RES` (0x7B). Activation bundle that sets all
+ * patch thresholds at once.
+ *
+ * Request wire format (7 bytes): `[0] 0x1B, [1] insulinRemainsThreshold, [2] expiryThreshold,
+ * [3..4] maxBasalSpeed = [int,centi], [5..6] maxBolusDose = [int,centi], [7] buzzFlag`.
+ *
+ * **Wire-format notes:**
+ * - `insulinRemainsThreshold` is a single wire byte, so `INS_REMAIN_RANGE` is 10..255; a value > 255
+ * would wrap on encode (300 → 0x2C = 44), silently misprogramming the low-insulin alarm threshold,
+ * so it is rejected instead. Every real caller feeds the low-insulin reminder preference (entries
+ * 20..50 U), so nothing legitimately exceeds one byte; an out-of-range caller fails loudly rather
+ * than alarming 6× too late.
+ * - `buzzFlag` is the inverted buzz flag → `buzzUse=true → 0x01`, `buzzUse=false → 0x00` (same double
+ * inversion as [BuzzModeCommand]).
+ *
+ * Response (0x7B): `[0] 0x7B, [1] resultCode` → [SimpleResultResponse].
+ */
+class ThresholdSetupCommand(
+ private val insulinRemainsThreshold: Int,
+ private val expiryThreshold: Int,
+ private val maxBasalSpeed: Double,
+ private val maxBolusDose: Double,
+ private val buzzUse: Boolean
+) : BleCommand {
+
+ init {
+ require(insulinRemainsThreshold in INS_REMAIN_RANGE) { "insulinRemainsThreshold out of range $INS_REMAIN_RANGE" }
+ require(expiryThreshold in EXPIRY_RANGE) { "expiryThreshold out of range $EXPIRY_RANGE" }
+ require(maxBasalSpeed in MAX_BASAL_SPEED_RANGE) { "maxBasalSpeed out of range $MAX_BASAL_SPEED_RANGE" }
+ require(maxBolusDose in MAX_BOLUS_DOSE_RANGE) { "maxBolusDose out of range $MAX_BOLUS_DOSE_RANGE" }
+ }
+
+ override val requestOpcode: Byte = REQUEST_OPCODE
+ override val expectedResponseOpcode: Byte = RESPONSE_OPCODE
+
+ override fun encode(): ByteArray =
+ byteArrayOf(requestOpcode, insulinRemainsThreshold.toByte(), expiryThreshold.toByte()) +
+ encodeUnitCenti(maxBasalSpeed) +
+ encodeUnitCenti(maxBolusDose) +
+ byteArrayOf(if (buzzUse) BUZZ_ON else BUZZ_OFF)
+
+ override fun decode(responsePayload: ByteArray): SimpleResultResponse {
+ requireResponseFrame(responsePayload, RESPONSE_OPCODE, MIN_RESPONSE_LENGTH)
+ return SimpleResultResponse(responsePayload.u(1))
+ }
+
+ companion object {
+
+ const val REQUEST_OPCODE: Byte = 0x1B
+ const val RESPONSE_OPCODE: Byte = 0x7B
+ // One wire byte; 10..255 valid, larger values would wrap — see class KDoc.
+ private val INS_REMAIN_RANGE = 10..255
+ private val EXPIRY_RANGE = 24..167
+ private val MAX_BASAL_SPEED_RANGE = 0.05..15.0
+ private val MAX_BOLUS_DOSE_RANGE = 0.05..25.0
+ private const val BUZZ_ON: Byte = 0x01 // buzzUse=true → 0x01 (inverted)
+ private const val BUZZ_OFF: Byte = 0x00 // buzzUse=false → 0x00 (inverted)
+ private const val MIN_RESPONSE_LENGTH = 2
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleEnums.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleEnums.kt
new file mode 100644
index 000000000000..2e3263adb8f5
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleEnums.kt
@@ -0,0 +1,99 @@
+package app.aaps.pump.carelevo.ble.data
+
+enum class BondingState {
+ BOND_NONE,
+ BOND_BONDING,
+ BOND_BONDED,
+ BOND_ERROR;
+
+ companion object {
+
+ fun Int.codeToBondingResult() = when (this) {
+ -1 -> BOND_NONE
+ 10 -> BOND_NONE
+ 11 -> BOND_BONDING
+ 12 -> BOND_BONDED
+ else -> throw IllegalArgumentException("Invalid code")
+ }
+ }
+}
+
+enum class PeripheralConnectionState {
+ CONN_STATE_NONE,
+ CONN_STATE_CONNECTING,
+ CONN_STATE_CONNECTED,
+ CONN_STATE_DISCONNECTING,
+ CONN_STATE_DISCONNECTED;
+
+ companion object {
+
+ fun Int.codeToConnectionResult() = when (this) {
+ -1 -> CONN_STATE_NONE
+ 0 -> CONN_STATE_DISCONNECTED
+ 1 -> CONN_STATE_CONNECTING
+ 2 -> CONN_STATE_CONNECTED
+ 3 -> CONN_STATE_DISCONNECTING
+ else -> throw IllegalArgumentException("Invalid code")
+ }
+ }
+}
+
+enum class ServiceDiscoverState {
+ DISCOVER_STATE_NONE,
+ DISCOVER_STATE_DISCOVERED,
+ DISCOVER_STATE_FAILED,
+ DISCOVER_STATE_CLEARED;
+
+ companion object {
+
+ fun Int.codeToDiscoverResult() = when (this) {
+ -1 -> DISCOVER_STATE_CLEARED
+ 0 -> DISCOVER_STATE_DISCOVERED
+ else -> DISCOVER_STATE_FAILED
+ }
+ }
+}
+
+enum class DeviceModuleState {
+ DEVICE_NONE,
+ DEVICE_STATE_OFF,
+ DEVICE_STATE_TUNING_OFF,
+ DEVICE_STATE_ON,
+ DEVICE_STATE_TURNING_ON;
+
+ companion object {
+
+ fun Int.codeToDeviceResult() = when (this) {
+ -1 -> DEVICE_NONE
+ 10 -> DEVICE_STATE_OFF
+ 11 -> DEVICE_STATE_TURNING_ON
+ 12 -> DEVICE_STATE_ON
+ 13 -> DEVICE_STATE_TUNING_OFF
+ else -> throw IllegalArgumentException("Invalid code")
+ }
+ }
+}
+
+enum class NotificationState {
+ NOTIFICATION_NONE,
+ NOTIFICATION_ENABLED,
+ NOTIFICATION_DISABLED;
+
+ companion object {
+
+ fun Int.codeToNotificationResult() = when (this) {
+ -1 -> NOTIFICATION_NONE
+ 0 -> NOTIFICATION_DISABLED
+ 1 -> NOTIFICATION_ENABLED
+ else -> throw IllegalArgumentException("Invalid code")
+ }
+ }
+}
+
+enum class FailureState {
+ FAILURE_INVALID_PARAMS,
+ FAILURE_RESOURCE_NOT_INITIALIZED,
+ FAILURE_PERMISSION_NOT_GRANTED,
+ FAILURE_BT_NOT_ENABLED,
+ FAILURE_COMMAND_NOT_EXECUTABLE
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleModels.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleModels.kt
new file mode 100644
index 000000000000..4e6139fc3403
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleModels.kt
@@ -0,0 +1,103 @@
+package app.aaps.pump.carelevo.ble.data
+
+import android.bluetooth.BluetoothDevice
+
+data class ScannedDevice(
+ var device: BluetoothDevice,
+ var rssi: Int
+)
+
+data class BleState(
+ val isEnabled: DeviceModuleState,
+ val isBonded: BondingState,
+ val isServiceDiscovered: ServiceDiscoverState,
+ val isConnected: PeripheralConnectionState,
+ val isNotificationEnabled: NotificationState
+)
+
+fun BleState.isAvailable(): Boolean {
+ return isEnabled != DeviceModuleState.DEVICE_STATE_OFF
+}
+
+fun BleState.isPeripheralConnected(): Boolean {
+ return isConnected == PeripheralConnectionState.CONN_STATE_CONNECTED
+}
+
+fun BleState.isConnected(): Boolean {
+ return isEnabled == DeviceModuleState.DEVICE_STATE_ON &&
+ isBonded == BondingState.BOND_BONDED &&
+ isConnected == PeripheralConnectionState.CONN_STATE_CONNECTED &&
+ isServiceDiscovered == ServiceDiscoverState.DISCOVER_STATE_DISCOVERED &&
+ isNotificationEnabled == NotificationState.NOTIFICATION_ENABLED
+}
+
+fun BleState.shouldBeConnected(): Boolean {
+ return isEnabled == DeviceModuleState.DEVICE_STATE_ON &&
+ isBonded == BondingState.BOND_BONDED &&
+ isConnected == PeripheralConnectionState.CONN_STATE_CONNECTED &&
+ isServiceDiscovered != ServiceDiscoverState.DISCOVER_STATE_DISCOVERED &&
+ isNotificationEnabled != NotificationState.NOTIFICATION_ENABLED
+}
+
+fun BleState.shouldBeDiscovered(): Boolean {
+ return isEnabled == DeviceModuleState.DEVICE_STATE_ON &&
+ isBonded == BondingState.BOND_BONDED &&
+ isServiceDiscovered == ServiceDiscoverState.DISCOVER_STATE_DISCOVERED &&
+ isNotificationEnabled != NotificationState.NOTIFICATION_ENABLED
+}
+
+fun BleState.shouldBeNotificationEnabled(): Boolean {
+ return isEnabled == DeviceModuleState.DEVICE_STATE_ON &&
+ isBonded == BondingState.BOND_BONDED &&
+ isConnected == PeripheralConnectionState.CONN_STATE_CONNECTED &&
+ isServiceDiscovered == ServiceDiscoverState.DISCOVER_STATE_DISCOVERED &&
+ isNotificationEnabled == NotificationState.NOTIFICATION_ENABLED
+}
+
+fun BleState.isDiscoverCleared(): Boolean {
+ return isEnabled == DeviceModuleState.DEVICE_STATE_ON &&
+ isBonded == BondingState.BOND_BONDED &&
+ isConnected == PeripheralConnectionState.CONN_STATE_DISCONNECTED &&
+ isServiceDiscovered == ServiceDiscoverState.DISCOVER_STATE_CLEARED &&
+ isNotificationEnabled == NotificationState.NOTIFICATION_DISABLED
+}
+
+fun BleState.isReInitialized(): Boolean {
+ return isEnabled == DeviceModuleState.DEVICE_STATE_ON &&
+ isBonded == BondingState.BOND_NONE &&
+ isConnected == PeripheralConnectionState.CONN_STATE_DISCONNECTED &&
+ isServiceDiscovered == ServiceDiscoverState.DISCOVER_STATE_DISCOVERED &&
+ isNotificationEnabled == NotificationState.NOTIFICATION_DISABLED
+}
+
+fun BleState.isAbnormalFailed(): Boolean {
+ return isEnabled == DeviceModuleState.DEVICE_STATE_ON &&
+ isBonded == BondingState.BOND_NONE &&
+ isConnected == PeripheralConnectionState.CONN_STATE_DISCONNECTED &&
+ isServiceDiscovered == ServiceDiscoverState.DISCOVER_STATE_DISCOVERED &&
+ isNotificationEnabled == NotificationState.NOTIFICATION_DISABLED
+}
+
+fun BleState.isAbnormalBondingFailed(): Boolean {
+ return isEnabled == DeviceModuleState.DEVICE_STATE_ON &&
+ isBonded == BondingState.BOND_NONE &&
+ isConnected == PeripheralConnectionState.CONN_STATE_CONNECTED &&
+ isServiceDiscovered == ServiceDiscoverState.DISCOVER_STATE_DISCOVERED &&
+ isNotificationEnabled == NotificationState.NOTIFICATION_DISABLED
+}
+
+fun BleState.isFailed(): Boolean {
+ return isEnabled == DeviceModuleState.DEVICE_STATE_ON &&
+ isBonded == BondingState.BOND_NONE &&
+ isConnected == PeripheralConnectionState.CONN_STATE_CONNECTED &&
+ isServiceDiscovered == ServiceDiscoverState.DISCOVER_STATE_NONE &&
+ isNotificationEnabled == NotificationState.NOTIFICATION_DISABLED
+}
+
+fun BleState.isPairingFailed(): Boolean {
+ return isEnabled == DeviceModuleState.DEVICE_STATE_ON &&
+ isBonded == BondingState.BOND_NONE &&
+ isConnected == PeripheralConnectionState.CONN_STATE_DISCONNECTED &&
+ isServiceDiscovered == ServiceDiscoverState.DISCOVER_STATE_NONE &&
+ isNotificationEnabled == NotificationState.NOTIFICATION_NONE
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleParams.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleParams.kt
new file mode 100644
index 000000000000..2ec6dca10cfa
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleParams.kt
@@ -0,0 +1,14 @@
+package app.aaps.pump.carelevo.ble.data
+
+import java.util.UUID
+
+data class BleParams(
+ val cccd: UUID,
+ val serviceUuid: UUID,
+ val txUuid: UUID,
+ val rxUUID: UUID
+)
+
+data class ConfigParams(
+ val isForeground: Boolean = true
+)
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleResults.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleResults.kt
new file mode 100644
index 000000000000..159272911bb9
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/data/CarelevoBleResults.kt
@@ -0,0 +1,57 @@
+package app.aaps.pump.carelevo.ble.data
+
+import java.util.UUID
+
+data class CharacterResult(
+ val uuidCharacteristic: UUID? = null,
+ val value: ByteArray? = null,
+ val codeStatus: Int? = null
+) {
+
+ override fun equals(other: Any?): Boolean {
+ if (this === other) return true
+ if (javaClass != other?.javaClass) return false
+
+ other as CharacterResult
+
+ if (uuidCharacteristic != other.uuidCharacteristic) return false
+ if (value != null) {
+ if (other.value == null) return false
+ if (!value.contentEquals(other.value)) return false
+ } else if (other.value != null) return false
+ if (codeStatus != other.codeStatus) return false
+
+ return true
+ }
+
+ override fun hashCode(): Int {
+ var result = uuidCharacteristic?.hashCode() ?: 0
+ result = 31 * result + (value?.contentHashCode() ?: 0)
+ result = 31 * result + (codeStatus ?: 0)
+ return result
+ }
+}
+
+sealed class PeripheralScanResult(
+ open val value: List
+) {
+
+ data class Init(
+ override val value: List
+ ) : PeripheralScanResult(value)
+
+ data class Success(
+ override val value: List
+ ) : PeripheralScanResult(value)
+
+ data class Failed(
+ override val value: List
+ ) : PeripheralScanResult(value)
+}
+
+sealed class CommandResult {
+ data class Pending(val data: T) : CommandResult()
+ data class Success(val data: T) : CommandResult()
+ data class Failure(val state: FailureState, val message: String) : CommandResult()
+ data class Error(val e: Throwable) : CommandResult()
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/gatt/BleTransportGattConnection.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/gatt/BleTransportGattConnection.kt
new file mode 100644
index 000000000000..39e7d7bd6677
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/gatt/BleTransportGattConnection.kt
@@ -0,0 +1,197 @@
+package app.aaps.pump.carelevo.ble.gatt
+
+import app.aaps.core.interfaces.pump.ble.BleTransport
+import app.aaps.core.interfaces.pump.ble.BleTransportListener
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.util.UUID
+
+/**
+ * Adapts the shared fleet [BleTransport] to carelevo's [GattConnection] contract, so the
+ * [app.aaps.pump.carelevo.ble.BleClientImpl] correlation layer runs on the same BLE transport
+ * abstraction Dana/Equil/Medtrum use.
+ *
+ * It registers itself as the transport's single [BleTransportListener] and translates each callback
+ * into either:
+ * - a per-op [CompletableDeferred] that unblocks a suspend [GattConnection] method, or
+ * - a [GattEvent] on the hot [events] flow (for [BleClient]'s notification routing and
+ * connection-state observers).
+ *
+ * Internally: per-op [CompletableDeferred]s for the suspend ops plus an events-[SharedFlow] fed from
+ * the [BleTransportListener] callbacks.
+ *
+ * **Semantic note (write acks):** [BleTransportListener.onCharacteristicWritten] carries
+ * no status, so a write the BLE stack silently drops is NOT fast-failed with [GattWriteException] —
+ * it degrades to the caller's `withTimeout(...)`, which every [BleClient.request] already applies.
+ * The *not-connected* case is still fast-failed (the transport calls `onConnectionStateChanged(false)`
+ * synchronously from the write). This matches the fleet transport behaviour.
+ *
+ * **Single-characteristic transport:** the shared `BleGatt` has one hardcoded write and one notify
+ * characteristic and no write-type parameter, so [writeCharacteristic]'s `withResponse` flag is not
+ * honored (writes are always acknowledged) and the `uuid` args are validated against the
+ * constructor UUIDs rather than used for routing — a mismatched UUID fails loudly instead of silently
+ * targeting the wrong characteristic.
+ *
+ * Threading: [gattMutex] serializes suspend ops; `CompletableDeferred.complete(...)` is thread-safe
+ * and called directly from the (binder thread) listener callbacks. Events are likewise emitted
+ * SYNCHRONOUSLY from the callbacks via [emitEvent] (`tryEmit` into the 64-slot buffer) — an async
+ * `scope.launch { emit(...) }` detour would open a lost-event window at session teardown: a
+ * response arriving just as the per-op timeout cancels [scope] would silently never reach
+ * [BleClient]'s router, and a pump that DID execute a dose command would be reported as failed.
+ * [scope] is only a fallback for the (pathological) buffer-full case.
+ *
+ * One adapter instance owns the transport's single listener slot for one connection lifecycle;
+ * [close] releases it.
+ *
+ * @param writeUuid stamped onto emitted [GattEvent.WriteAck] (the transport has one write char).
+ * @param notifyUuid stamped onto emitted [GattEvent.Notification] (the transport has one notify char).
+ */
+class BleTransportGattConnection(
+ private val transport: BleTransport,
+ private val writeUuid: UUID,
+ private val notifyUuid: UUID,
+ private val scope: CoroutineScope
+) : GattConnection, BleTransportListener {
+
+ private val _events = MutableSharedFlow(extraBufferCapacity = 64)
+ override val events: SharedFlow = _events.asSharedFlow()
+
+ private val gattMutex = Mutex()
+
+ @Volatile
+ private var writeAck: CompletableDeferred? = null
+
+ @Volatile
+ private var discoveryAck: CompletableDeferred? = null
+
+ @Volatile
+ private var descriptorAck: CompletableDeferred? = null
+
+ @Volatile
+ private var closed = false
+
+ init {
+ transport.setListener(this)
+ }
+
+ /**
+ * Opens the underlying GATT connection to [address]. Not part of [GattConnection] (which models
+ * an already-open connection) — callers await [GattEvent.ConnectionStateChanged]`(CONNECTED)` on
+ * [events] before calling [discoverServices]. Returns `false` if the BLE stack refused to start
+ * the connection (e.g. missing permission or unknown device).
+ */
+ fun connect(address: String): Boolean = transport.gatt.connect(address)
+
+ // ===== GattConnection =====
+
+ override suspend fun writeCharacteristic(
+ uuid: UUID,
+ payload: ByteArray,
+ withResponse: Boolean
+ ) = gattMutex.withLock {
+ // Self-guard: after close() the transport listener is null, so the not-connected callback
+ // below can no longer abort the deferred — fail fast instead of hanging until the caller's
+ // withTimeout.
+ if (closed) throw GattWriteException("connection closed")
+ require(uuid == writeUuid) { "unexpected write characteristic $uuid; transport has a single write char $writeUuid" }
+ val deferred = CompletableDeferred()
+ writeAck = deferred
+ try {
+ // Fire-and-forget on the shared transport; if not connected it synchronously calls
+ // onConnectionStateChanged(false), which aborts this deferred → fast-fail preserved.
+ transport.gatt.writeCharacteristic(payload)
+ val acked = deferred.await()
+ if (!acked) throw GattWriteException("onCharacteristicWritten reported failure")
+ } finally {
+ writeAck = null
+ }
+ }
+
+ override suspend fun discoverServices() = gattMutex.withLock {
+ if (closed) throw GattDiscoveryException("connection closed")
+ val deferred = CompletableDeferred()
+ discoveryAck = deferred
+ try {
+ transport.gatt.discoverServices()
+ if (!deferred.await()) throw GattDiscoveryException("onServicesDiscovered reported failure")
+ } finally {
+ discoveryAck = null
+ }
+ }
+
+ override suspend fun enableNotifications(uuid: UUID) = gattMutex.withLock {
+ if (closed) throw GattDiscoveryException("connection closed")
+ require(uuid == notifyUuid) { "unexpected notify characteristic $uuid; transport has a single notify char $notifyUuid" }
+ val deferred = CompletableDeferred()
+ descriptorAck = deferred
+ try {
+ transport.gatt.enableNotifications()
+ if (!deferred.await()) throw GattDiscoveryException("onDescriptorWritten reported failure")
+ } finally {
+ descriptorAck = null
+ }
+ }
+
+ override fun close() {
+ // Idempotent (GattConnection contract). The flag also makes subsequent suspend ops fail fast
+ // rather than hang, since setListener(null) below disables the not-connected abort callback.
+ closed = true
+ // Abort any in-flight suspending operations first — the transport's close() is not
+ // guaranteed to produce a final onConnectionStateChanged on every chipset.
+ writeAck?.completeExceptionally(GattWriteException("connection closed"))
+ discoveryAck?.completeExceptionally(GattDiscoveryException("connection closed"))
+ descriptorAck?.completeExceptionally(GattDiscoveryException("connection closed"))
+ transport.gatt.close()
+ transport.setListener(null)
+ }
+
+ // ===== BleTransportListener =====
+
+ /**
+ * Delivers [event] to [events] synchronously on the calling (binder) thread. Falls back to an
+ * async emit only if the buffer is full — see the class-level threading note for why the
+ * synchronous path is load-bearing.
+ */
+ private fun emitEvent(event: GattEvent) {
+ if (!_events.tryEmit(event)) scope.launch { _events.emit(event) }
+ }
+
+ override fun onConnectionStateChanged(connected: Boolean) {
+ val state = if (connected) GattConnState.CONNECTED else GattConnState.DISCONNECTED
+ emitEvent(GattEvent.ConnectionStateChanged(state))
+ if (!connected) {
+ // Connection gone — abort any in-flight operations (BleClient aborts its own request
+ // waiter separately off the DISCONNECTED event).
+ writeAck?.completeExceptionally(GattWriteException("disconnected"))
+ discoveryAck?.completeExceptionally(GattDiscoveryException("disconnected"))
+ descriptorAck?.completeExceptionally(GattDiscoveryException("disconnected"))
+ }
+ }
+
+ override fun onServicesDiscovered(success: Boolean) {
+ discoveryAck?.complete(success)
+ emitEvent(GattEvent.ServicesDiscovered(success))
+ }
+
+ override fun onDescriptorWritten() {
+ // Transport only invokes this on GATT_SUCCESS; a failed CCCD write produces no callback and
+ // is surfaced by the caller's withTimeout (mirrors the fleet transport behaviour).
+ descriptorAck?.complete(true)
+ }
+
+ override fun onCharacteristicChanged(data: ByteArray) {
+ emitEvent(GattEvent.Notification(notifyUuid, data.copyOf()))
+ }
+
+ override fun onCharacteristicWritten() {
+ // No status on the shared listener — a delivered write-ack is treated as success.
+ writeAck?.complete(true)
+ emitEvent(GattEvent.WriteAck(writeUuid, true))
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/gatt/GattConnection.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/gatt/GattConnection.kt
new file mode 100644
index 000000000000..1b04a2137484
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/ble/gatt/GattConnection.kt
@@ -0,0 +1,112 @@
+package app.aaps.pump.carelevo.ble.gatt
+
+import kotlinx.coroutines.flow.SharedFlow
+import java.util.UUID
+
+/**
+ * Thin abstraction over the Android `BluetoothGatt` lifecycle for a single peripheral.
+ *
+ * The concrete production implementation wraps `BluetoothGatt` + `BluetoothGattCallback`
+ * and bridges the callback into a hot [SharedFlow] of [GattEvent]s. Tests substitute
+ * `FakeGattConnection` to script BLE behaviour without Android types.
+ *
+ * Designed as the single chokepoint through which all BLE I/O for the CareLevo driver
+ * flows. Callers above this layer never reference `BluetoothGatt` directly.
+ */
+interface GattConnection {
+
+ /**
+ * Hot, multicast stream of GATT events as the BLE stack reports them.
+ *
+ * Subscribers receive only events emitted after they subscribe (no replay).
+ * Use [BleClient]-style suspend operations for request/response correlation —
+ * direct subscription to this flow is intended for connection-state observers
+ * and unsolicited notifications (alarms, status pushes).
+ */
+ val events: SharedFlow
+
+ /**
+ * Writes [payload] to the characteristic identified by [uuid].
+ *
+ * Suspends until the BLE stack delivers a matching [GattEvent.WriteAck], then returns
+ * normally on success or throws [GattWriteException] on failure. Does not impose
+ * its own timeout — wrap the call in `withTimeout(...)` if a deadline is needed.
+ *
+ * @param withResponse `true` selects acknowledged write (`WRITE_TYPE_DEFAULT`),
+ * `false` selects fire-and-forget (`WRITE_TYPE_NO_RESPONSE`).
+ */
+ suspend fun writeCharacteristic(
+ uuid: UUID,
+ payload: ByteArray,
+ withResponse: Boolean = true
+ )
+
+ /**
+ * Initiates service discovery and suspends until the BLE stack reports completion.
+ * Throws [GattDiscoveryException] if the stack reports failure.
+ */
+ suspend fun discoverServices()
+
+ /**
+ * Subscribes to peripheral-initiated notifications/indications on [uuid].
+ * Subsequent [GattEvent.Notification] events for [uuid] will appear in [events].
+ */
+ suspend fun enableNotifications(uuid: UUID)
+
+ /**
+ * Releases the underlying `BluetoothGatt` and aborts any in-flight suspending
+ * operations with their typed exceptions (`GattWriteException` or
+ * `GattDiscoveryException`). The [events] flow remains active for any existing
+ * subscribers — callers relying on flow completion should instead cancel the
+ * scope that owns the subscription. Idempotent — safe to call repeatedly.
+ */
+ fun close()
+}
+
+/**
+ * Anything the GATT layer reports asynchronously. Sealed so consumers must handle
+ * every case exhaustively.
+ */
+sealed interface GattEvent {
+
+ /** A peripheral-initiated notification or indication. */
+ data class Notification(
+ val uuid: UUID,
+ val payload: ByteArray
+ ) : GattEvent
+
+ /** Connection state transitioned. */
+ data class ConnectionStateChanged(
+ val state: GattConnState
+ ) : GattEvent
+
+ /**
+ * Service discovery finished. [ok] is `true` only when the stack reported
+ * `GATT_SUCCESS`; consumers should also re-check the discovered service set
+ * matches what the protocol expects before proceeding.
+ */
+ data class ServicesDiscovered(
+ val ok: Boolean
+ ) : GattEvent
+
+ /** Acknowledgement of a previously requested write. */
+ data class WriteAck(
+ val uuid: UUID,
+ val ok: Boolean
+ ) : GattEvent
+}
+
+/**
+ * Coarse connection state derived from `BluetoothProfile.STATE_*` and the gatt's
+ * disconnect/close lifecycle.
+ */
+enum class GattConnState {
+
+ CONNECTING,
+ CONNECTED,
+ DISCONNECTING,
+ DISCONNECTED
+}
+
+class GattWriteException(message: String, cause: Throwable? = null) : RuntimeException(message, cause)
+class GattDiscoveryException(message: String, cause: Throwable? = null) : RuntimeException(message, cause)
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/command/CarelevoActivationCommands.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/command/CarelevoActivationCommands.kt
new file mode 100644
index 000000000000..fb9059db9fa0
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/command/CarelevoActivationCommands.kt
@@ -0,0 +1,76 @@
+package app.aaps.pump.carelevo.command
+
+import app.aaps.core.interfaces.queue.CustomCommand
+import app.aaps.pump.carelevo.domain.type.AlarmCause
+import app.aaps.pump.carelevo.domain.type.AlarmType
+
+/**
+ * Activation operations routed through the AAPS CommandQueue (managed connect-before-execute /
+ * reconnect). See [CarelevoActivationExecutor]. Each is a marker command; the executor runs the
+ * corresponding use case blocking on the queue thread and returns the result.
+ */
+
+class CmdNeedleCheck : CustomCommand {
+
+ override val statusDescription: String = "NEEDLE CHECK"
+}
+
+class CmdSetBasal : CustomCommand {
+
+ override val statusDescription: String = "SET BASAL"
+}
+
+class CmdAdditionalPriming : CustomCommand {
+
+ override val statusDescription: String = "ADDITIONAL PRIMING"
+}
+
+class CmdDiscard : CustomCommand {
+
+ override val statusDescription: String = "DISCARD PATCH"
+}
+
+class CmdPumpStop(val durationMin: Int) : CustomCommand {
+
+ override val statusDescription: String = "PUMP STOP"
+}
+
+class CmdPumpResume : CustomCommand {
+
+ override val statusDescription: String = "PUMP RESUME"
+}
+
+class CmdTimeZoneUpdate(val insulinAmount: Int) : CustomCommand {
+
+ override val statusDescription: String = "TIMEZONE UPDATE"
+}
+
+class CmdUpdateMaxBolus(val maxBolusDose: Double) : CustomCommand {
+
+ override val statusDescription: String = "UPDATE MAX BOLUS"
+}
+
+class CmdUpdateLowInsulinNotice(val hours: Int) : CustomCommand {
+
+ override val statusDescription: String = "UPDATE LOW INSULIN NOTICE"
+}
+
+class CmdUpdateExpiredThreshold(val hours: Int) : CustomCommand {
+
+ override val statusDescription: String = "UPDATE EXPIRY THRESHOLD"
+}
+
+class CmdUpdateBuzzer(val on: Boolean) : CustomCommand {
+
+ override val statusDescription: String = "UPDATE BUZZER"
+}
+
+class CmdAlarmClear(val alarmId: String, val alarmType: AlarmType, val alarmCause: AlarmCause) : CustomCommand {
+
+ override val statusDescription: String = "ALARM CLEAR"
+}
+
+class CmdAlarmClearPatchDiscard(val alarmId: String, val alarmType: AlarmType, val alarmCause: AlarmCause) : CustomCommand {
+
+ override val statusDescription: String = "ALARM CLEAR PATCH DISCARD"
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/command/CarelevoActivationExecutor.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/command/CarelevoActivationExecutor.kt
new file mode 100644
index 000000000000..eb271a37b160
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/command/CarelevoActivationExecutor.kt
@@ -0,0 +1,441 @@
+package app.aaps.pump.carelevo.command
+
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.pump.PumpEnactResult
+import app.aaps.core.interfaces.queue.CustomCommand
+import app.aaps.pump.carelevo.ble.BleCommand
+import app.aaps.pump.carelevo.ble.CarelevoBleSession
+import app.aaps.pump.carelevo.ble.commands.AdditionalPrimingCommand
+import app.aaps.pump.carelevo.ble.commands.AlarmClearCommand
+import app.aaps.pump.carelevo.ble.commands.BuzzModeCommand
+import app.aaps.pump.carelevo.ble.commands.InfusionThresholdCommand
+import app.aaps.pump.carelevo.ble.commands.NeedleStatusCommand
+import app.aaps.pump.carelevo.ble.commands.NoticeThresholdCommand
+import app.aaps.pump.carelevo.ble.commands.PatchDiscardCommand
+import app.aaps.pump.carelevo.ble.commands.PumpResumeCommand
+import app.aaps.pump.carelevo.ble.commands.PumpStopCommand
+import app.aaps.pump.carelevo.ble.commands.SafetyCheckCommand
+import app.aaps.pump.carelevo.ble.commands.SetTimeCommand
+import app.aaps.pump.carelevo.ble.commands.SimpleResultResponse
+import app.aaps.pump.carelevo.common.CarelevoPatch
+import app.aaps.pump.carelevo.domain.model.bt.SafetyCheckResult
+import app.aaps.pump.carelevo.domain.model.bt.SafetyCheckResultModel
+import app.aaps.pump.carelevo.domain.type.SafetyProgress
+import app.aaps.pump.carelevo.domain.usecase.alarm.AlarmClearPatchDiscardUseCase
+import app.aaps.pump.carelevo.domain.usecase.alarm.AlarmClearRequestUseCase
+import app.aaps.pump.carelevo.domain.usecase.basal.CarelevoSetBasalProgramUseCase
+import app.aaps.pump.carelevo.domain.usecase.infusion.CarelevoPumpResumeUseCase
+import app.aaps.pump.carelevo.domain.usecase.infusion.CarelevoPumpStopUseCase
+import app.aaps.pump.carelevo.domain.usecase.patch.CarelevoPatchNeedleInsertionCheckUseCase
+import app.aaps.pump.carelevo.domain.usecase.patch.CarelevoPatchSafetyCheckUseCase
+import app.aaps.pump.carelevo.domain.usecase.userSetting.CarelevoUpdateLowInsulinNoticeAmountUseCase
+import app.aaps.pump.carelevo.domain.usecase.userSetting.CarelevoUpdateMaxBolusDoseUseCase
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.runBlocking
+import org.joda.time.DateTime
+import javax.inject.Inject
+import javax.inject.Provider
+import javax.inject.Singleton
+import kotlin.jvm.optionals.getOrNull
+
+/**
+ * Runs activation operations that are routed through the AAPS [app.aaps.core.interfaces.queue.CommandQueue]
+ * as custom commands. The plugin's `executeCustomCommand` delegates here; it is invoked on the queue
+ * worker thread. Each op runs BLOCKING over the coroutine [CarelevoBleSession] (its own per-op
+ * connection session — connect → exchange → close) and returns a [PumpEnactResult]. The use cases are
+ * persistence-only seams (`persistX`/`buildX`); all BLE goes through [CarelevoBleSession].
+ *
+ * The safety check streams progress (`Progress` → `Success`/`Error`); since a custom command returns a
+ * single result, that progress is republished on [safetyProgress] so the wizard can drive its countdown.
+ */
+@Singleton
+class CarelevoActivationExecutor @Inject constructor(
+ private val aapsLogger: AAPSLogger,
+ private val pumpEnactResultProvider: Provider,
+ private val carelevoPatch: CarelevoPatch,
+ private val safetyCheckUseCase: CarelevoPatchSafetyCheckUseCase,
+ private val needleCheckUseCase: CarelevoPatchNeedleInsertionCheckUseCase,
+ private val setBasalUseCase: CarelevoSetBasalProgramUseCase,
+ private val pumpStopUseCase: CarelevoPumpStopUseCase,
+ private val pumpResumeUseCase: CarelevoPumpResumeUseCase,
+ private val updateMaxBolusDoseUseCase: CarelevoUpdateMaxBolusDoseUseCase,
+ private val updateLowInsulinNoticeAmountUseCase: CarelevoUpdateLowInsulinNoticeAmountUseCase,
+ private val alarmClearRequestUseCase: AlarmClearRequestUseCase,
+ private val alarmClearPatchDiscardUseCase: AlarmClearPatchDiscardUseCase,
+ private val bleSession: CarelevoBleSession
+) {
+
+ private companion object {
+
+ private const val RESULT_SUCCESS = 0 // pump result byte 0 = SUCCESS / BY_REQ
+ private const val STOP_RESUME_SUB_ID = 0 // stop/resume use subId/causeId = 0
+ private const val RESUME_MODE = 1 // resume mode = 1
+ private const val TIMEZONE_SUB_ID = 1 // set-time subId = 1 for the timezone/DST update path
+ private const val TIMEZONE_AID_MODE = 0 // set-time aidMode = 0
+ private const val NEEDLE_CHECK_TIMEOUT_MS = 90_000L // physical cannula insertion may take a while
+ private const val SAFETY_PROGRESS_HEADROOM_SEC = 30 // Progress timeout = firstFrame.durationSeconds + 30
+ }
+
+ private val _safetyProgress = MutableSharedFlow(extraBufferCapacity = 16)
+ val safetyProgress: SharedFlow = _safetyProgress.asSharedFlow()
+
+ fun execute(command: CustomCommand): PumpEnactResult? = when (command) {
+ is CmdSafetyCheck -> runSafetyCheck()
+ is CmdNeedleCheck -> runNeedleCheck()
+ is CmdSetBasal -> runSetBasal()
+ is CmdAdditionalPriming -> runSingleWrite("additionalPriming") { AdditionalPrimingCommand() }
+ is CmdDiscard -> runDiscard()
+ is CmdPumpStop -> runPumpStop(command.durationMin)
+ is CmdPumpResume -> runPumpResume()
+ is CmdTimeZoneUpdate -> runSingleWrite("timeZoneUpdate") {
+ SetTimeCommand(subId = TIMEZONE_SUB_ID, volume = command.insulinAmount, aidMode = TIMEZONE_AID_MODE, dateTime = DateTime.now())
+ }
+
+ is CmdUpdateMaxBolus -> runUpdateMaxBolus(command.maxBolusDose)
+ is CmdUpdateLowInsulinNotice -> runUpdateLowInsulinNotice(command.hours)
+ is CmdUpdateExpiredThreshold -> runUpdateExpiredThreshold(command.hours)
+ is CmdUpdateBuzzer -> runUpdateBuzzer(command.on)
+ is CmdAlarmClear -> runAlarmClear(command)
+ is CmdAlarmClearPatchDiscard -> runAlarmClearPatchDiscard(command)
+ else -> null
+ }
+
+ /**
+ * Initial basal program (**delivery-critical**): build the 3-program plan with the use case's exact
+ * mapping, send all three [app.aaps.pump.carelevo.ble.commands.BasalProgramCommand]s over ONE session
+ * (via [CarelevoBleSession.runBasalProgram]), and only on all-success reuse the use case's `mode=1` +
+ * infusion-info persist. Activation-only op.
+ */
+ private fun runSetBasal(): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val profile = carelevoPatch.profile.value?.getOrNull()
+ ?: return result.success(false).enacted(false).comment("profile not set")
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val plan = setBasalUseCase.buildBasalProgramPlan(profile)
+ val programmed = runBlocking {
+ bleSession.runBasalProgram(address, plan.programs)
+ }
+ val persisted = if (programmed) setBasalUseCase.persistBasalProgram(plan.segments) else false
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.setBasal programmed=$programmed persisted=$persisted")
+ val ok = programmed && persisted
+ result.success(ok).enacted(ok)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.setBasal FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Pump stop (suspend delivery): write [PumpStopCommand] on the session; on success
+ * (`resultCode == 0`) persist the suspended state (`pumpStopUseCase.persistStopped`).
+ */
+ private fun runPumpStop(durationMin: Int): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking {
+ bleSession.runSingle(address, PumpStopCommand(durationMinutes = durationMin, subId = STOP_RESUME_SUB_ID))
+ }
+ if (response.resultCode != RESULT_SUCCESS) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.pumpStop rejected result=${response.resultCode}")
+ return result.success(false).enacted(false).comment("stop result ${response.resultCode}")
+ }
+ val persisted = pumpStopUseCase.persistStopped(durationMin)
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.pumpStop OK durationMin=$durationMin persisted=$persisted")
+ result.success(persisted).enacted(persisted)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.pumpStop FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ private fun runPumpResume(): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking {
+ bleSession.runSingle(address, PumpResumeCommand(mode = RESUME_MODE, subId = STOP_RESUME_SUB_ID))
+ }
+ if (response.resultCode != RESULT_SUCCESS) { // 0 = BY_REQ
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.pumpResume rejected result=${response.resultCode}")
+ return result.success(false).enacted(false).comment("resume result ${response.resultCode}")
+ }
+ val persisted = pumpResumeUseCase.persistResumed()
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.pumpResume OK persisted=$persisted")
+ result.success(persisted).enacted(persisted)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.pumpResume FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Buzzer setting via [BuzzModeCommand] (0x18 → 0x78). Pure write, no persistence (the preference is
+ * the source of truth).
+ */
+ private fun runUpdateBuzzer(on: Boolean): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking {
+ bleSession.runSingle(address, BuzzModeCommand(use = on))
+ }
+ val success = response.resultCode == RESULT_SUCCESS
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.buzzer OK on=$on result=${response.resultCode}")
+ result.success(success).enacted(success)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.buzzer FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Max-bolus setting. Never push a threshold mid-bolus (persist locally + defer via
+ * `needMaxBolusDoseSyncPatch`); otherwise write [InfusionThresholdCommand]
+ * (max-volume), then persist with `synced` = the patch confirmed. On any failure the value is still
+ * persisted with the sync flag set so the deferred-sync re-pushes on reconnect.
+ */
+ private fun runUpdateMaxBolus(value: Double): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ if (updateMaxBolusDoseUseCase.isBolusRunning()) {
+ val persisted = updateMaxBolusDoseUseCase.persistMaxBolusDose(value, synced = false)
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.maxBolus bolus-running → deferred persisted=$persisted")
+ return result.success(persisted).enacted(persisted)
+ }
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking {
+ bleSession.runSingle(address, InfusionThresholdCommand(isMaxVolume = true, value = value))
+ }
+ val pushed = response.resultCode == RESULT_SUCCESS
+ val persisted = updateMaxBolusDoseUseCase.persistMaxBolusDose(value, synced = pushed)
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.maxBolus OK value=$value result=${response.resultCode} persisted=$persisted")
+ val success = pushed && persisted
+ result.success(success).enacted(success)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.maxBolus FAILED", e)
+ updateMaxBolusDoseUseCase.persistMaxBolusDose(value, synced = false) // keep desired value + defer re-sync
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Low-insulin-notice setting. The 0x75 response fabricates a result of 0, so arrival = success.
+ * Persists via the use case with `synced` = arrived; on failure the value is
+ * persisted deferred for the next reconnect.
+ */
+ private fun runUpdateLowInsulinNotice(hours: Int): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking {
+ bleSession.runSingle(address, NoticeThresholdCommand(thresholdType = NoticeThresholdCommand.TYPE_LOW_INSULIN, value = hours))
+ }
+ val pushed = response.resultCode == RESULT_SUCCESS
+ val persisted = updateLowInsulinNoticeAmountUseCase.persistLowInsulinNoticeAmount(hours, synced = pushed)
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.lowInsulinNotice OK hours=$hours result=${response.resultCode} persisted=$persisted")
+ val success = pushed && persisted
+ result.success(success).enacted(success)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.lowInsulinNotice FAILED", e)
+ updateLowInsulinNoticeAmountUseCase.persistLowInsulinNoticeAmount(hours, synced = false)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Patch-expiry-reminder setting. No userSettingInfo persist (the preference is the source of truth),
+ * so this is a pure BLE write like the buzzer; arrival of the 0x75 frame (fabricated result 0) = success.
+ */
+ private fun runUpdateExpiredThreshold(hours: Int): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking {
+ bleSession.runSingle(address, NoticeThresholdCommand(thresholdType = NoticeThresholdCommand.TYPE_EXPIRY, value = hours))
+ }
+ val success = response.resultCode == RESULT_SUCCESS
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.expiryThreshold OK hours=$hours result=${response.resultCode}")
+ result.success(success).enacted(success)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.expiryThreshold FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Shared path for a pure single-response WRITE with no persistence (buzzer-style ops:
+ * additional-priming, timezone, …): run [command] on the session, success = `resultCode == 0`.
+ * Runs on the queue worker (blocked inside the command).
+ */
+ private fun runSingleWrite(label: String, command: () -> BleCommand): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking {
+ bleSession.runSingle(address, command())
+ }
+ val success = response.resultCode == RESULT_SUCCESS
+ aapsLogger.info(LTag.PUMPCOMM, "ble.$label OK result=${response.resultCode}")
+ result.success(success).enacted(success)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "ble.$label FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * BLE discard (tell the patch to stop delivering) + teardown. Routed through the queue so the
+ * teardown runs HERE on the queue worker thread (no reconnect race, ~300ms BLE teardown off the Main
+ * thread). The STOP write alone ([PatchDiscardCommand] 0x36) decides success; a teardown failure must
+ * not flip an already-stopped patch to failure. The DB-only force-discard stays in the ViewModels as
+ * the fallback for when the patch cannot be reached at all.
+ */
+ private fun runDiscard(): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ val stopped = try {
+ val response = runBlocking {
+ bleSession.runSingle(address, PatchDiscardCommand())
+ }
+ response.resultCode == RESULT_SUCCESS
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.discard stop exception", e)
+ false
+ }
+ if (stopped) carelevoPatch.discardTeardown()
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.discard stopped=$stopped")
+ return result.success(stopped).enacted(stopped)
+ }
+
+ /**
+ * Cannula-insertion (needle) check. Long timeout — the pump reports 0x79 only after the physical
+ * insertion. `resultCode == 0` = SUCCESS; the `checkNeedle`/failure-count persist is reused from the
+ * use case. Activation-only op.
+ */
+ private fun runNeedleCheck(): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking {
+ bleSession.runSingle(address, NeedleStatusCommand(), timeoutMs = NEEDLE_CHECK_TIMEOUT_MS)
+ }
+ val inserted = response.resultCode == RESULT_SUCCESS
+ val persisted = needleCheckUseCase.persistNeedleResult(inserted)
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.needleCheck inserted=$inserted result=${response.resultCode} persisted=$persisted")
+ val ok = inserted && persisted
+ result.success(ok).enacted(ok)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.needleCheck FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Safety Check over `requestStream`. Streams each 0x72 frame; progress frames
+ * (REP_REQUEST/REP_REQUEST1) drive the wizard countdown via [_safetyProgress] (one Progress emit),
+ * the terminal SUCCESS frame persists `checkSafety` + emits Success, any other
+ * terminal is an Error. Activation-only op.
+ */
+ private fun runSafetyCheck(): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ var success = false
+ var progressEmitted = false
+ return try {
+ runBlocking {
+ bleSession.runSafetyCheck(address) { frame ->
+ when (frame.resultCode) {
+ SafetyCheckCommand.REP_REQUEST, SafetyCheckCommand.REP_REQUEST1 -> {
+ if (!progressEmitted) {
+ progressEmitted = true
+ _safetyProgress.tryEmit(SafetyProgress.Progress((frame.durationSeconds + SAFETY_PROGRESS_HEADROOM_SEC).toLong()))
+ }
+ }
+
+ SafetyCheckCommand.RESULT_SUCCESS -> {
+ if (safetyCheckUseCase.persistSafetyChecked()) {
+ success = true
+ _safetyProgress.tryEmit(SafetyProgress.Success(SafetyCheckResultModel(SafetyCheckResult.SUCCESS, frame.insulinVolume, frame.durationSeconds)))
+ } else {
+ _safetyProgress.tryEmit(SafetyProgress.Error(IllegalStateException("update patch info is failed")))
+ }
+ }
+
+ else ->
+ _safetyProgress.tryEmit(SafetyProgress.Error(IllegalStateException("safety check failed: result ${frame.resultCode}")))
+ }
+ }
+ }
+ result.success(success).enacted(success)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.safetyCheck FAILED", e)
+ _safetyProgress.tryEmit(SafetyProgress.Error(e))
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Alarm clear: map the cause to the wire alarm-type byte, send [AlarmClearCommand] (0x47 → 0xA7),
+ * and on `resultCode == 0` reuse the use case's remove-alarm persist.
+ */
+ private fun runAlarmClear(command: CmdAlarmClear): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val alarmTypeByte = alarmClearRequestUseCase.commandAlarmType(command.alarmCause)
+ val cause = command.alarmCause.code ?: 0
+ val response = runBlocking {
+ bleSession.runSingle(address, AlarmClearCommand(alarmTypeByte, cause))
+ }
+ val cleared = response.resultCode == RESULT_SUCCESS
+ val persisted = if (cleared) alarmClearRequestUseCase.persistAlarmCleared(command.alarmId) else false
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.alarmClear cleared=$cleared result=${response.resultCode} persisted=$persisted")
+ val ok = cleared && persisted
+ result.success(ok).enacted(ok)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.alarmClear FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Alarm-triggered patch discard: send [PatchDiscardCommand] (0x36) then reuse the use case's DB
+ * cleanup (ack + reset sync flags + delete infusion/patch). Unlike the plain [runDiscard], this does
+ * NOT unbond (no `discardTeardown`).
+ */
+ private fun runAlarmClearPatchDiscard(command: CmdAlarmClearPatchDiscard): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking {
+ bleSession.runSingle(address, PatchDiscardCommand())
+ }
+ val discarded = response.resultCode == RESULT_SUCCESS
+ val persisted = if (discarded) alarmClearPatchDiscardUseCase.persistAlarmDiscarded(command.alarmId) else false
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.alarmClearPatchDiscard discarded=$discarded result=${response.resultCode} persisted=$persisted")
+ val ok = discarded && persisted
+ result.success(ok).enacted(ok)
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.alarmClearPatchDiscard FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/command/CmdSafetyCheck.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/command/CmdSafetyCheck.kt
new file mode 100644
index 000000000000..c7c47951e502
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/command/CmdSafetyCheck.kt
@@ -0,0 +1,13 @@
+package app.aaps.pump.carelevo.command
+
+import app.aaps.core.interfaces.queue.CustomCommand
+
+/**
+ * Activation safety-check routed through the AAPS CommandQueue so it gets the queue's managed
+ * connect-before-execute / reconnect lifecycle (instead of the wizard doing a direct BLE call that
+ * silently no-ops when the link has dropped).
+ */
+class CmdSafetyCheck : CustomCommand {
+
+ override val statusDescription: String = "SAFETY CHECK"
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoAlarmActionHandler.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoAlarmActionHandler.kt
new file mode 100644
index 000000000000..783e96f82de0
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoAlarmActionHandler.kt
@@ -0,0 +1,298 @@
+package app.aaps.pump.carelevo.common
+
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.queue.CommandQueue
+import app.aaps.core.interfaces.rx.AapsSchedulers
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.coordinator.CarelevoAlarmClearCoordinator
+import app.aaps.pump.carelevo.domain.model.alarm.CarelevoAlarmInfo
+import app.aaps.pump.carelevo.domain.type.AlarmCause
+import app.aaps.pump.carelevo.domain.type.AlarmType
+import app.aaps.pump.carelevo.domain.usecase.alarm.CarelevoAlarmInfoUseCase
+import app.aaps.pump.carelevo.presentation.model.AlarmEvent
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.kotlin.plusAssign
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * SINGLE owner of the in-memory active-alarm queue and of the per-cause alarm-clear state machine,
+ * shared by BOTH clear surfaces: the Android notification action ([CarelevoAlarmNotifier]) and the
+ * in-app full-screen alarm ([app.aaps.pump.carelevo.presentation.viewmodel.CarelevoAlarmViewModel],
+ * which delegates here and keeps only sound/UI concerns).
+ *
+ * Persistence rule: an alarm that has been successfully handled is REMOVED from the persisted
+ * store ([CarelevoAlarmInfoUseCase.acknowledgeAlarm]) as well as from [alarmQueue] — otherwise it
+ * resurrects on the next cold load or foreground refresh.
+ */
+@Singleton
+class CarelevoAlarmActionHandler @Inject constructor(
+ private val aapsLogger: AAPSLogger,
+ private val aapsSchedulers: AapsSchedulers,
+ private val commandQueue: CommandQueue,
+ private val alarmUseCase: CarelevoAlarmInfoUseCase,
+ private val alarmClearCoordinator: CarelevoAlarmClearCoordinator
+) {
+
+ // App-lifetime scope (this is a @Singleton): drives the suspend queue-routed alarm-clear ops.
+ private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+
+ private val _alarmQueue = MutableStateFlow>(emptyList())
+ val alarmQueue = _alarmQueue.asStateFlow()
+
+ private val _alarmQueueEmptyEvent = MutableSharedFlow(
+ replay = 0,
+ extraBufferCapacity = 1,
+ onBufferOverflow = BufferOverflow.DROP_OLDEST
+ )
+ val alarmQueueEmptyEvent = _alarmQueueEmptyEvent.asSharedFlow()
+
+ /**
+ * UI requests the state machine cannot execute itself (launch the Bluetooth-enable intent,
+ * show a failure message). Collected by the in-app alarm host; a request that fires while no
+ * UI is mounted is intentionally lossy (DROP_OLDEST) — the alarm itself stays queued.
+ */
+ private val _uiRequests = MutableSharedFlow(
+ replay = 0,
+ extraBufferCapacity = 4,
+ onBufferOverflow = BufferOverflow.DROP_OLDEST
+ )
+ val uiRequests = _uiRequests.asSharedFlow()
+
+ /** The alarm most recently entering the clear flow (used by the UI for status text). */
+ var alarmInfo: CarelevoAlarmInfo? = null
+
+ private val compositeDisposable = CompositeDisposable()
+
+ fun observeAlarms() =
+ alarmUseCase.observeAlarms()
+ .map { it.orElse(emptyList()) }
+
+ fun getAlarmsOnce(): Single> =
+ alarmUseCase.getAlarmsOnce()
+ .map { it.orElse(emptyList()) }
+
+ /** (Re)load the persisted active alarms into [alarmQueue], most severe tier first. */
+ fun loadActiveAlarms() {
+ compositeDisposable += getAlarmsOnce()
+ .subscribeOn(aapsSchedulers.io)
+ .observeOn(aapsSchedulers.main)
+ .subscribe(
+ { alarms ->
+ val sorted = alarms
+ .filter { !it.isAcknowledged }
+ .sortedWith(compareBy { it.alarmType.code }.thenBy { it.createdAt })
+ _alarmQueue.value = sorted
+ if (sorted.isEmpty()) emitQueueEmpty()
+ },
+ { e -> aapsLogger.error(LTag.PUMPCOMM, "loadActiveAlarms.error", e) }
+ )
+ }
+
+ fun triggerEvent(event: AlarmEvent) {
+ when (event) {
+ is AlarmEvent.ClearAlarm -> startAlarmClearProcess(event.info)
+ else -> Unit
+ }
+ }
+
+ /**
+ * The per-cause dispatch for a user-confirmed alarm. Branch groups covering the full union of
+ * [AlarmCause]:
+ * - resume-timeout → clear on patch, ack, resume delivery
+ * - clearable ALERT/NOTICE causes → clear on patch, ack; on failure fall back to local ack
+ * - WARNING causes (patch fault) → discard the patch (graceful when reachable, local force-quit
+ * when not) — the patch is being abandoned
+ * - auto-off WARNING → clear + resume (delivery was only paused)
+ * - Bluetooth-off ALERT → local ack + request BT enable + reconnect
+ * - informational LGS/BG/timezone notices → no patch op
+ */
+ private fun startAlarmClearProcess(info: CarelevoAlarmInfo) {
+ alarmInfo = info
+ val alarmType = info.alarmType
+ val alarmCause = info.cause
+
+ aapsLogger.debug(LTag.PUMPCOMM, "startAlarmClearProcess alarmType=$alarmType, alarmCause=$alarmCause")
+
+ // The BLE ops go through the CommandQueue (it reconnects a resting pump first); an
+ // unreachable patch is handled by the on-failure fallback path rather than a pre-gate.
+ when (alarmCause) {
+ AlarmCause.ALARM_ALERT_RESUME_INSULIN_DELIVERY_TIMEOUT,
+ AlarmCause.ALARM_WARNING_NOT_USED_APP_AUTO_OFF -> {
+ scope.launch {
+ // Resume only if the alarm was actually cleared on the patch — do not resume delivery
+ // into an unresolved alarm condition.
+ if (alarmClearCoordinator.clearAlarmOnPatch(info)) {
+ acknowledgeAndRemoveAlarm(info.alarmId)
+ alarmClearCoordinator.resumeInfusion()
+ } else {
+ _uiRequests.emit(AlarmEvent.ShowToastMessage(R.string.alarm_feat_msg_check_patch_connect))
+ }
+ }
+ }
+
+ AlarmCause.ALARM_ALERT_OUT_OF_INSULIN,
+ AlarmCause.ALARM_ALERT_PATCH_EXPIRED_PHASE_1,
+ AlarmCause.ALARM_ALERT_PATCH_EXPIRED_PHASE_2,
+ AlarmCause.ALARM_ALERT_APP_NO_USE,
+ AlarmCause.ALARM_ALERT_PATCH_APPLICATION_INCOMPLETE,
+ AlarmCause.ALARM_ALERT_LOW_BATTERY,
+ AlarmCause.ALARM_ALERT_INVALID_TEMPERATURE,
+ AlarmCause.ALARM_NOTICE_LOW_INSULIN,
+ AlarmCause.ALARM_NOTICE_PATCH_EXPIRED,
+ AlarmCause.ALARM_NOTICE_ATTACH_PATCH_CHECK -> {
+ scope.launch {
+ if (alarmClearCoordinator.clearAlarmOnPatch(info)) acknowledgeAndRemoveAlarm(info.alarmId)
+ else startAlarmAlertAbnormalClearProcess(info, alarmCause)
+ }
+ }
+
+ AlarmCause.ALARM_ALERT_BLE_NOT_CONNECTED,
+ AlarmCause.ALARM_ALERT_BLUETOOTH_OFF -> {
+ startAlarmAlertAbnormalClearProcess(info, alarmCause)
+ }
+
+ AlarmCause.ALARM_WARNING_LOW_INSULIN,
+ AlarmCause.ALARM_WARNING_PATCH_EXPIRED_PHASE_1,
+ AlarmCause.ALARM_WARNING_INVALID_TEMPERATURE,
+ AlarmCause.ALARM_WARNING_BLE_NOT_CONNECTED,
+ AlarmCause.ALARM_WARNING_INCOMPLETE_PATCH_SETTING,
+ AlarmCause.ALARM_WARNING_SELF_DIAGNOSIS_FAILED,
+ AlarmCause.ALARM_WARNING_PATCH_EXPIRED,
+ AlarmCause.ALARM_WARNING_PATCH_ERROR,
+ AlarmCause.ALARM_WARNING_PUMP_CLOGGED,
+ AlarmCause.ALARM_WARNING_NEEDLE_INSERTION_ERROR,
+ AlarmCause.ALARM_WARNING_LOW_BATTERY -> {
+ discardPatchForAlarm(info)
+ }
+
+ AlarmCause.ALARM_NOTICE_BG_CHECK,
+ AlarmCause.ALARM_NOTICE_TIME_ZONE_CHANGED,
+ AlarmCause.ALARM_NOTICE_LGS_START,
+ AlarmCause.ALARM_NOTICE_LGS_FINISHED_DISCONNECTED_PATCH_OR_CGM,
+ AlarmCause.ALARM_NOTICE_LGS_FINISHED_PAUSE_LGS,
+ AlarmCause.ALARM_NOTICE_LGS_FINISHED_TIME_OVER,
+ AlarmCause.ALARM_NOTICE_LGS_FINISHED_OFF_LGS,
+ AlarmCause.ALARM_NOTICE_LGS_FINISHED_HIGH_BG,
+ AlarmCause.ALARM_NOTICE_LGS_FINISHED_UNKNOWN,
+ AlarmCause.ALARM_NOTICE_LGS_NOT_WORKING -> {
+ // Informational — no patch-side state to clear; remove locally on confirm.
+ acknowledgeAndRemoveAlarm(info.alarmId)
+ }
+
+ AlarmCause.ALARM_UNKNOWN -> {
+ if (alarmType == AlarmType.WARNING) discardPatchForAlarm(info)
+ }
+ }
+ }
+
+ /** WARNING-tier handling: the patch is faulty and being abandoned. */
+ private fun discardPatchForAlarm(info: CarelevoAlarmInfo) {
+ if (alarmClearCoordinator.isPatchReachable()) {
+ // Reachable: tell the patch to discard (via the queue), then abandon it locally.
+ scope.launch {
+ alarmClearCoordinator.discardOnAlarm(info)
+ startAlarmClearPatchForceQuitProcess()
+ }
+ } else {
+ // Unreachable/faulty patch: abandon locally NOW — do not wait on the queue's
+ // connect-loop (up to ~119s) while a critical warning keeps sounding.
+ startAlarmClearPatchForceQuitProcess()
+ }
+ }
+
+ /**
+ * The patch could not be reached (or the link itself is the alarm): acknowledge locally so the
+ * user is not held hostage by an unclearable alarm, then run any cause-specific recovery.
+ */
+ private fun startAlarmAlertAbnormalClearProcess(info: CarelevoAlarmInfo, alarmCause: AlarmCause) {
+ compositeDisposable += alarmUseCase.acknowledgeAlarm(info.alarmId)
+ .subscribeOn(aapsSchedulers.io)
+ .observeOn(aapsSchedulers.io)
+ .subscribe(
+ {
+ when (alarmCause) {
+ AlarmCause.ALARM_ALERT_BLUETOOTH_OFF -> {
+ // Keep the queue entry visible until the link is confirmed back;
+ // ask the UI to fire the system Bluetooth-enable intent.
+ startReconnect(info.alarmId)
+ scope.launch { _uiRequests.emit(AlarmEvent.RequestBluetoothEnable) }
+ }
+
+ else -> removeFromQueue(info.alarmId)
+ }
+ },
+ { error -> aapsLogger.error(LTag.PUMPCOMM, "abnormalClear.acknowledge failed cause=$alarmCause", error) }
+ )
+ }
+
+ private fun startReconnect(alarmId: String) {
+ // Reconnect + refresh through the queue (managed connect-before-execute) rather than a raw BLE
+ // connect that would fight the queue-owned lifecycle. Ack the alarm once the link is confirmed.
+ scope.launch {
+ if (commandQueue.readStatus("Bluetooth re-enabled after alarm").success) {
+ aapsLogger.debug(LTag.PUMPCOMM, "reconnect readStatus success")
+ acknowledgeAndRemoveAlarm(alarmId)
+ } else {
+ aapsLogger.debug(LTag.PUMPCOMM, "reconnect readStatus failed")
+ }
+ }
+ }
+
+ private fun startAlarmClearPatchForceQuitProcess() {
+ alarmClearCoordinator.forceQuitTeardown { clearAllAlarms() }
+ }
+
+ /**
+ * Handled alarm: remove from the persisted store AND from the in-memory queue. Without the
+ * store removal a cleared alarm resurrects on the next cold load / foreground refresh.
+ */
+ fun acknowledgeAndRemoveAlarm(alarmId: String) {
+ compositeDisposable += alarmUseCase.acknowledgeAlarm(alarmId)
+ .subscribeOn(aapsSchedulers.io)
+ .subscribe(
+ { removeFromQueue(alarmId) },
+ { e ->
+ aapsLogger.error(LTag.PUMPCOMM, "acknowledgeAndRemoveAlarm.persist failed id=$alarmId", e)
+ // Still drop it from the visible queue — the user confirmed it; worst case it
+ // reappears on the next refresh instead of being stuck on screen forever.
+ removeFromQueue(alarmId)
+ }
+ )
+ }
+
+ private fun removeFromQueue(alarmId: String) {
+ _alarmQueue.value = _alarmQueue.value.filterNot { it.alarmId == alarmId }
+ if (_alarmQueue.value.isEmpty()) emitQueueEmpty()
+ }
+
+ fun clearAllAlarms() {
+ compositeDisposable += alarmUseCase.clearAlarms()
+ .subscribeOn(aapsSchedulers.io)
+ .observeOn(aapsSchedulers.io)
+ .subscribe(
+ {
+ _alarmQueue.value = emptyList()
+ emitQueueEmpty()
+ },
+ { e ->
+ aapsLogger.error(LTag.PUMPCOMM, "clearAllAlarms.error error=$e")
+ })
+ }
+
+ private fun emitQueueEmpty() {
+ val ok = _alarmQueueEmptyEvent.tryEmit(Unit)
+ aapsLogger.debug(LTag.PUMPCOMM, "alarmQueue empty emit=$ok")
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoAlarmNotifier.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoAlarmNotifier.kt
new file mode 100644
index 000000000000..364a9010547f
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoAlarmNotifier.kt
@@ -0,0 +1,311 @@
+package app.aaps.pump.carelevo.common
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import androidx.annotation.StringRes
+import androidx.core.app.NotificationCompat
+import androidx.core.text.HtmlCompat
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.ProcessLifecycleOwner
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.notifications.NotificationAction
+import app.aaps.core.interfaces.notifications.NotificationId
+import app.aaps.core.interfaces.notifications.NotificationLevel
+import app.aaps.core.interfaces.rx.AapsSchedulers
+import app.aaps.core.interfaces.sharedPreferences.SP
+import app.aaps.core.interfaces.utils.DateUtil
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.common.keys.CarelevoIntPreferenceKey
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.pump.carelevo.domain.model.alarm.CarelevoAlarmInfo
+import app.aaps.pump.carelevo.domain.type.AlarmCause
+import app.aaps.pump.carelevo.domain.type.AlarmType.Companion.isCritical
+import app.aaps.pump.carelevo.ext.transformNotificationStringResources
+import app.aaps.pump.carelevo.presentation.model.AlarmEvent
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.kotlin.plusAssign
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Presentation half of the alarm pipeline: observes the persisted active-alarm set (via
+ * [CarelevoAlarmActionHandler]) and surfaces it — the in-app AAPS "top notification" cards
+ * ([showTopNotification], with the clear action wired back to the shared state machine), the
+ * system-tray notification for backgrounded users ([showNotification]), and the [alarms] StateFlow
+ * the Compose alarm host renders from. The plugin (`CarelevoPumpPlugin.handleAlarms`) decides per
+ * emission which surface a given alarm set takes; [alarmHostActive] tells it whether the in-app
+ * host is mounted.
+ */
+@Singleton
+class CarelevoAlarmNotifier @Inject constructor(
+ private val context: Context,
+ private val aapsLogger: AAPSLogger,
+ private val aapsSchedulers: AapsSchedulers,
+ private val dateUtil: DateUtil,
+ private val notificationManager: app.aaps.core.interfaces.notifications.NotificationManager,
+ private val sp: SP,
+ private val alarmActionHandler: CarelevoAlarmActionHandler
+) {
+
+ private val disposables = CompositeDisposable()
+ private val _alarms = MutableStateFlow>(emptyList())
+ val alarms = _alarms.asStateFlow()
+ private var onAlarmsUpdated: ((List) -> Unit)? = null
+ private val channelId = "carelevo_alarm_channel"
+
+ /**
+ * True while the in-app Compose alarm host ([app.aaps.pump.carelevo.compose.alarm.CarelevoAlarmHost])
+ * is mounted (user is on the Carelevo screen). The plugin uses this to decide whether a critical
+ * alarm is already being presented (host shows the full-screen alarm + sound) or must fall back
+ * to the global `UiInteraction.runAlarm` so a backgrounded/elsewhere user is never left silent.
+ */
+ @Volatile var alarmHostActive: Boolean = false
+
+ fun startObserving(
+ onAlarmsUpdated: (List) -> Unit
+ ) {
+ this.onAlarmsUpdated = onAlarmsUpdated
+ createNotificationChannel()
+
+ disposables += alarmActionHandler.observeAlarms()
+ .subscribeOn(aapsSchedulers.io)
+ .observeOn(aapsSchedulers.main)
+ .subscribe(
+ { alarms -> handleAlarmsInternal(alarms) },
+ { e -> aapsLogger.error(LTag.PUMPCOMM, "observeAlarms.error error=$e") }
+ )
+ }
+
+ fun refreshAlarms() {
+ disposables += alarmActionHandler.getAlarmsOnce()
+ .subscribeOn(aapsSchedulers.io)
+ .observeOn(aapsSchedulers.main)
+ .subscribe(
+ { alarms -> handleAlarmsInternal(alarms) },
+ { e -> aapsLogger.error(LTag.PUMPCOMM, "refreshAlarms.error error=$e") }
+ )
+ }
+
+ private fun handleAlarmsInternal(alarms: List) {
+ aapsLogger.debug(LTag.PUMPCOMM, "handleAlarmsInternal alarms=$alarms")
+ _alarms.value = alarms
+
+ if (!isInForeground) {
+ alarms.forEach { alarm ->
+ showNotification(alarm)
+ }
+ }
+
+ onAlarmsUpdated?.invoke(alarms)
+ }
+
+ fun showTopNotification(alarms: List) {
+ // CARELEVO_PATCH_ALERT is allowMultiple=true (a fresh instance per post with no replace), so
+ // clear the previous carelevo cards before re-posting the current set. This gives
+ // replace-on-refresh semantics while still letting distinct concurrent alarms coexist.
+ notificationManager.dismiss(NotificationId.CARELEVO_PATCH_ALERT)
+ alarms.forEach { newAlarm ->
+ val (titleRes, descRes, btnRes) = newAlarm.cause.transformNotificationStringResources()
+
+ val descArgs = buildDescArgsFor(newAlarm)
+ val desc = buildDescription(descRes, descArgs)
+ aapsLogger.debug(LTag.PUMPCOMM, "showTopNotification titleRes=$titleRes descArgs=$descArgs desc=$desc")
+ // Critical tiers get the id's declared URGENT level + alarm sound (the shared
+ // NotificationManagerImpl gates its ramping alarm on URGENT && soundRes != null) and do
+ // not auto-expire — an unhandled critical alarm must not disappear on its own.
+ // Non-critical notices stay NORMAL/silent and also persist until handled.
+ val critical = newAlarm.alarmType.isCritical()
+ notificationManager.post(
+ id = NotificationId.CARELEVO_PATCH_ALERT,
+ text = context.getString(titleRes) + "\n" + HtmlCompat.fromHtml(desc, HtmlCompat.FROM_HTML_MODE_LEGACY),
+ level = if (critical) NotificationLevel.URGENT else NotificationLevel.NORMAL,
+ actions = listOf(
+ NotificationAction(btnRes) {
+ alarmActionHandler.triggerEvent(AlarmEvent.ClearAlarm(info = newAlarm))
+ }
+ ),
+ date = dateUtil.now(),
+ soundRes = if (critical) CoreUiR.raw.error else null,
+ validityCheck = null,
+ )
+ }
+ }
+
+ fun stopObserving() {
+ disposables.clear()
+ }
+
+ fun showNotification(alarm: CarelevoAlarmInfo) {
+ val notificationManager =
+ context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+ val (titleRes, descRes, _) = alarm.cause.transformNotificationStringResources()
+ val description = buildNotificationDescription(alarm, descRes)
+
+ val contentPendingIntent = createAlarmActivityPendingIntent()
+
+ val notification = buildNotification(
+ title = context.getString(titleRes),
+ description = description,
+ contentIntent = contentPendingIntent
+ )
+
+ notificationManager.notify(alarm.alarmId.hashCode(), notification)
+ }
+
+ /** Builds the final body text from the alarm metadata and descRes. */
+ private fun buildNotificationDescription(
+ alarm: CarelevoAlarmInfo,
+ @StringRes descRes: Int?
+ ): String {
+ if (descRes == null) return ""
+ return when (alarm.cause) {
+ AlarmCause.ALARM_ALERT_OUT_OF_INSULIN,
+ AlarmCause.ALARM_NOTICE_LOW_INSULIN -> {
+ val remain = (alarm.value ?: 0).toString()
+ context.getString(descRes, remain)
+ }
+
+ AlarmCause.ALARM_NOTICE_PATCH_EXPIRED -> {
+ formatPatchExpired(descRes, alarm.value ?: 0)
+ }
+
+ AlarmCause.ALARM_NOTICE_BG_CHECK -> {
+ val span = formatBgCheckSpan(alarm.value ?: 0)
+ context.getString(descRes, span)
+ }
+
+ else -> context.getString(descRes)
+ }
+ }
+
+ private fun formatPatchExpired(@StringRes descRes: Int, totalHours: Int): String {
+ val days = totalHours / 24
+ val remainHours = totalHours % 24
+ return context.getString(descRes, days, remainHours)
+ }
+
+ private fun formatBgCheckSpan(totalMinutes: Int): String {
+ val hours = totalMinutes / 60
+ val minutes = totalMinutes % 60
+ return if (hours > 0) {
+ context.getString(
+ R.string.common_label_unit_value_duration_hour_and_minute,
+ hours, minutes
+ )
+ } else {
+ context.getString(
+ R.string.common_label_unit_value_minute,
+ minutes
+ )
+ }
+ }
+
+ private fun buildNotification(
+ title: String,
+ description: String,
+ contentIntent: PendingIntent
+ ): Notification {
+ return NotificationCompat.Builder(context, channelId)
+ .setSmallIcon(app.aaps.core.ui.R.drawable.notif_icon)
+ .setContentTitle(title)
+ .setContentText(description)
+ .setPriority(NotificationCompat.PRIORITY_HIGH)
+ .setContentIntent(contentIntent)
+ .setAutoCancel(true)
+ .build()
+ }
+
+ private fun createAlarmActivityPendingIntent(): PendingIntent {
+ val launchIntent =
+ context.packageManager.getLaunchIntentForPackage(context.packageName)
+ ?.apply {
+ addFlags(
+ Intent.FLAG_ACTIVITY_NEW_TASK or
+ Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
+ )
+ }
+
+ val flags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+
+ return PendingIntent.getActivity(
+ context,
+ 0,
+ launchIntent,
+ flags
+ )
+ }
+
+ private fun createNotificationChannel() {
+ // Resource strings — the channel name/description are user-visible in the system's
+ // notification settings.
+ val name = context.getString(R.string.carelevo_alarm_channel_name)
+ val descriptionText = context.getString(R.string.carelevo_alarm_channel_description)
+ val importance = NotificationManager.IMPORTANCE_HIGH
+ val channel = NotificationChannel(channelId, name, importance).apply {
+ description = descriptionText
+ }
+ val notificationManager: NotificationManager =
+ context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+ notificationManager.createNotificationChannel(channel)
+ }
+
+ private fun buildDescArgsFor(alarm: CarelevoAlarmInfo): List = when (alarm.cause) {
+ AlarmCause.ALARM_NOTICE_LOW_INSULIN,
+ AlarmCause.ALARM_ALERT_OUT_OF_INSULIN -> {
+ val lowInsulinNoticeAmount = sp.getInt(CarelevoIntPreferenceKey.CARELEVO_LOW_INSULIN_EXPIRATION_REMINDER_HOURS.key, 30)
+ listOf((lowInsulinNoticeAmount).toString())
+ }
+
+ AlarmCause.ALARM_NOTICE_PATCH_EXPIRED -> {
+ val expiry = sp.getInt(CarelevoIntPreferenceKey.CARELEVO_PATCH_EXPIRATION_REMINDER_HOURS.key, 116)
+ aapsLogger.debug(LTag.PUMPCOMM, "buildDescArgsFor alarm=${alarm.value} expiry=$expiry")
+ val (days, hours) = splitDaysAndHours(expiry)
+ listOf(days.toString(), hours.toString())
+ }
+
+ AlarmCause.ALARM_NOTICE_BG_CHECK -> {
+ val totalMinutes = alarm.value ?: 0
+ listOf(formatBgCheckDuration(totalMinutes))
+ }
+
+ else -> emptyList()
+ }
+
+ private fun buildDescription(@StringRes descRes: Int?, args: List): String {
+ return descRes?.let { resId ->
+ if (args.isEmpty()) context.getString(resId) else context.getString(resId, *args.toTypedArray())
+ } ?: ""
+ }
+
+ private fun splitDaysAndHours(totalHours: Int): Pair {
+ val days = totalHours / 24
+ val hours = totalHours % 24
+ return days to hours
+ }
+
+ private fun formatBgCheckDuration(totalMinutes: Int): String {
+ val hours = totalMinutes / 60
+ val minutes = totalMinutes % 60
+ return when {
+ hours > 0 && minutes > 0 ->
+ context.getString(R.string.common_label_unit_value_duration_hour_and_minute, hours, minutes)
+
+ hours > 0 ->
+ context.getString(R.string.common_label_unit_value_duration_hour, hours)
+
+ else ->
+ context.getString(R.string.common_label_unit_value_minute, minutes)
+ }
+ }
+
+ val isInForeground: Boolean
+ get() = ProcessLifecycleOwner.get().lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoEventFlow.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoEventFlow.kt
new file mode 100644
index 000000000000..1314d8864f0e
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoEventFlow.kt
@@ -0,0 +1,49 @@
+package app.aaps.pump.carelevo.common
+
+import kotlinx.coroutines.InternalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.MutableSharedFlow
+import java.util.concurrent.atomic.AtomicBoolean
+
+interface EventFlow : Flow {
+ companion object {
+
+ const val DEFAULT_REPLAY: Int = 1
+ }
+}
+
+interface MutableEventFlow : EventFlow, FlowCollector
+
+@Suppress("FunctionName")
+fun MutableEventFlow(
+ replay: Int = EventFlow.DEFAULT_REPLAY
+): MutableEventFlow = EventFlowImpl(replay)
+
+fun MutableEventFlow.asEventFlow(): EventFlow = ReadOnlyEventFlow(this)
+
+private class ReadOnlyEventFlow(flow: EventFlow) : EventFlow by flow
+
+private class EventFlowImpl(
+ replay: Int
+) : MutableEventFlow {
+
+ private val flow: MutableSharedFlow> = MutableSharedFlow(replay = replay)
+
+ @InternalCoroutinesApi
+ override suspend fun collect(collector: FlowCollector) = flow.collect { slot ->
+ if (!slot.markConsumed()) {
+ collector.emit(slot.value)
+ }
+ }
+
+ override suspend fun emit(value: T) {
+ flow.emit(EventFlowSlot(value))
+ }
+}
+
+private class EventFlowSlot(val value: T) {
+
+ private val consumed: AtomicBoolean = AtomicBoolean(false)
+ fun markConsumed(): Boolean = consumed.getAndSet(true)
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoObserveReceiver.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoObserveReceiver.kt
new file mode 100644
index 000000000000..633dc49b3c5e
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoObserveReceiver.kt
@@ -0,0 +1,42 @@
+package app.aaps.pump.carelevo.common
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Observer
+
+/**
+ * Rx wrapper around a [BroadcastReceiver]: each subscription registers a receiver for [filter] and
+ * emits every matching [Intent]; disposing the subscription unregisters it (via
+ * [CarelevoReceiverDisposable]). Used by the plugin to observe Bluetooth adapter state changes.
+ *
+ * Registered NOT_EXPORTED — the only consumers listen to protected system broadcasts
+ * (e.g. `BluetoothAdapter.ACTION_STATE_CHANGED`), which the system delivers regardless; nothing
+ * here should ever be targetable by other apps.
+ */
+class CarelevoObserveReceiver(
+ private val context: Context,
+ private val filter: IntentFilter
+) : Observable() {
+
+ override fun subscribeActual(observer: Observer) {
+ object : BroadcastReceiver() {
+ override fun onReceive(context: Context?, intent: Intent?) {
+ intent?.let {
+ if (filter.matchAction(it.action)) {
+ observer.onNext(it)
+ }
+ }
+ }
+ }.apply {
+ observer.onSubscribe(CarelevoReceiverDisposable(context, this))
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
+ context.registerReceiver(this, filter, Context.RECEIVER_NOT_EXPORTED)
+ else
+ context.registerReceiver(this, filter)
+ }
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoPatch.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoPatch.kt
new file mode 100644
index 000000000000..8463897970bc
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoPatch.kt
@@ -0,0 +1,537 @@
+package app.aaps.pump.carelevo.common
+
+import app.aaps.core.data.model.TE
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.profile.Profile
+import app.aaps.core.interfaces.rx.AapsSchedulers
+import app.aaps.core.interfaces.rx.bus.RxBus
+import app.aaps.core.interfaces.rx.events.EventCustomActionsChanged
+import app.aaps.core.interfaces.rx.events.EventPumpStatusChanged
+import app.aaps.core.interfaces.rx.events.EventRefreshOverview
+import app.aaps.core.interfaces.sharedPreferences.SP
+import app.aaps.core.keys.DoubleKey
+import app.aaps.core.keys.interfaces.Preferences
+import app.aaps.pump.carelevo.ble.CarelevoBleTransport
+import app.aaps.pump.carelevo.ble.UnsolicitedMessage
+import app.aaps.pump.carelevo.ble.data.BleState
+import app.aaps.pump.carelevo.ble.data.DeviceModuleState
+import app.aaps.pump.carelevo.ble.data.isAvailable
+import app.aaps.pump.carelevo.common.keys.CarelevoIntPreferenceKey
+import app.aaps.pump.carelevo.common.model.PatchState
+import app.aaps.pump.carelevo.domain.model.ResponseResult
+import app.aaps.pump.carelevo.domain.model.alarm.CarelevoAlarmInfo
+import app.aaps.pump.carelevo.domain.model.bt.InfusionModeResult.Companion.codeToInfusionModeCommand
+import app.aaps.pump.carelevo.domain.model.bt.InfusionModeResult.Companion.commandToCode
+import app.aaps.pump.carelevo.domain.model.bt.PumpStateResult.Companion.codeToPumpStateCommand
+import app.aaps.pump.carelevo.domain.model.bt.PumpStateResult.Companion.commandToCode
+import app.aaps.pump.carelevo.domain.model.infusion.CarelevoInfusionInfoDomainModel
+import app.aaps.pump.carelevo.domain.model.patch.CarelevoPatchInfoDomainModel
+import app.aaps.pump.carelevo.domain.model.userSetting.CarelevoUserSettingInfoDomainModel
+import app.aaps.pump.carelevo.domain.type.AlarmCause
+import app.aaps.pump.carelevo.domain.type.AlarmType
+import app.aaps.pump.carelevo.domain.usecase.alarm.CarelevoAlarmInfoUseCase
+import app.aaps.pump.carelevo.domain.usecase.infusion.CarelevoInfusionInfoMonitorUseCase
+import app.aaps.pump.carelevo.domain.usecase.infusion.CarelevoPumpResumeUseCase
+import app.aaps.pump.carelevo.domain.usecase.patch.CarelevoPatchInfoMonitorUseCase
+import app.aaps.pump.carelevo.domain.usecase.patch.CarelevoPatchRptInfusionInfoProcessUseCase
+import app.aaps.pump.carelevo.domain.usecase.patch.model.CarelevoPatchRptInfusionInfoRequestModel
+import app.aaps.pump.carelevo.domain.usecase.userSetting.CarelevoCreateUserSettingInfoUseCase
+import app.aaps.pump.carelevo.domain.usecase.userSetting.CarelevoUserSettingInfoMonitorUseCase
+import app.aaps.pump.carelevo.domain.usecase.userSetting.model.CarelevoUserSettingInfoRequestModel
+import io.reactivex.rxjava3.core.Completable
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.kotlin.plusAssign
+import io.reactivex.rxjava3.subjects.BehaviorSubject
+import java.time.LocalDateTime
+import java.util.Optional
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import javax.inject.Inject
+import kotlin.jvm.optionals.getOrNull
+import kotlin.math.abs
+import kotlin.math.min
+
+class CarelevoPatch @Inject constructor(
+ private val transport: CarelevoBleTransport,
+ private val aapsSchedulers: AapsSchedulers,
+ private val rxBus: RxBus,
+ private val sp: SP,
+ private val preferences: Preferences,
+ private val aapsLogger: AAPSLogger,
+ private val infusionInfoMonitorUseCase: CarelevoInfusionInfoMonitorUseCase,
+ private val patchInfoMonitorUseCase: CarelevoPatchInfoMonitorUseCase,
+ private val userSettingInfoMonitorUseCase: CarelevoUserSettingInfoMonitorUseCase,
+ private val patchRptInfusionInfoProcessUseCase: CarelevoPatchRptInfusionInfoProcessUseCase,
+ private val createUserSettingInfoUseCase: CarelevoCreateUserSettingInfoUseCase,
+ private val carelevoAlarmInfoUseCase: CarelevoAlarmInfoUseCase,
+ private val pumpResumeUseCase: CarelevoPumpResumeUseCase
+) {
+
+ private val bleDisposable = CompositeDisposable()
+
+ private val infoDisposable = CompositeDisposable()
+
+ private var _isWorking = false
+ val isWorking get() = _isWorking
+
+ private val _btState: BehaviorSubject> = BehaviorSubject.create()
+ val btState get() = _btState
+
+ private val _patchState: BehaviorSubject> = BehaviorSubject.create()
+ val patchState get() = _patchState
+
+ private val _patchInfo: BehaviorSubject> = BehaviorSubject.create()
+ val patchInfo get() = _patchInfo
+
+ private val _infusionInfo: BehaviorSubject> = BehaviorSubject.create()
+ val infusionInfo get() = _infusionInfo
+
+ private val _userSettingInfo: BehaviorSubject> = BehaviorSubject.create()
+ val userSettingInfo get() = _userSettingInfo
+
+ private val _profile: BehaviorSubject> = BehaviorSubject.create()
+ val profile get() = _profile
+
+ /**
+ * Site placement chosen during the activation wizard's site-location step. Read by the needle
+ * insertion step when it records the CANNULA_CHANGE therapy event. Defaults to NONE (site
+ * rotation disabled or step skipped).
+ */
+ @Volatile var sitePlacementLocation: TE.Location = TE.Location.NONE
+ private set
+ @Volatile var sitePlacementArrow: TE.Arrow = TE.Arrow.NONE
+ private set
+
+ fun setSitePlacement(location: TE.Location, arrow: TE.Arrow) {
+ sitePlacementLocation = location
+ sitePlacementArrow = arrow
+ }
+
+ private var lastBtState: BleState? = null
+
+ fun initPatch() {
+ if (!isWorking) {
+ observePatchInfo()
+ observeChangeState()
+ observeInfusionInfo()
+ observeUserSettingInfo()
+ _isWorking = true
+ }
+ }
+
+ fun initPatchAndAwait(): Completable =
+ Completable.defer {
+ initPatch()
+ patchState
+ .filter { state ->
+ state == PatchState.NotConnectedNotBooting || state == PatchState.ConnectedBooted
+ }
+ .firstOrError()
+ .ignoreElement()
+ }
+
+ /** One-shot wrapper that shares the same init progress across duplicate calls. */
+ @Volatile private var inFlightInit: Completable? = null
+ fun initPatchOnce(): Completable = synchronized(this) {
+ inFlightInit?.let { return it }
+ val c = initPatchAndAwait()
+ .timeout(20, TimeUnit.SECONDS)
+ .cache()
+ .doFinally { synchronized(this) { inFlightInit = null } }
+ inFlightInit = c
+ c
+ }
+
+ fun getPatchInfoAddress(): String? {
+ return patchInfo.value?.getOrNull()?.address
+ }
+
+ /**
+ * Per-op sessions leave no resting link to observe, so "connected" collapses to patch validity:
+ * an activated patch with Bluetooth available is operational ([PatchState.ConnectedBooted] — every
+ * op dials its own session on demand), an activated patch with Bluetooth off is
+ * [PatchState.NotConnectedBooted], and no patch is [PatchState.NotConnectedNotBooting].
+ */
+ fun resolvePatchState(): PatchState {
+ val isPatchValid = patchInfo.value?.getOrNull() != null
+ val btAvailable = btState.value?.getOrNull()?.isAvailable() ?: false
+
+ return when {
+ !isPatchValid -> PatchState.NotConnectedNotBooting
+ btAvailable -> PatchState.ConnectedBooted
+ else -> PatchState.NotConnectedBooted
+ }
+ }
+
+ private fun observeChangeState() {
+ aapsLogger.debug(LTag.PUMPCOMM, "observeChangeState called")
+ bleDisposable += BehaviorSubject.combineLatest(
+ btState,
+ patchInfo
+ ) { _, _ ->
+ val result = resolvePatchState()
+ aapsLogger.debug(LTag.PUMPCOMM, "result : $result")
+
+ _patchState.onNext(Optional.ofNullable(result))
+
+ when (result) {
+ is PatchState.NotConnectedNotBooting -> {
+ aapsLogger.debug(LTag.PUMPCOMM, "patch state is no connection")
+ rxBus.send(EventPumpStatusChanged(EventPumpStatusChanged.Status.DISCONNECTED))
+ rxBus.send(EventRefreshOverview("Carelevo connection state", true))
+ rxBus.send(EventCustomActionsChanged())
+ }
+
+ is PatchState.ConnectedBooted -> {
+ aapsLogger.debug(LTag.PUMPCOMM, "patch state is ConnectedBooted")
+ rxBus.send(EventPumpStatusChanged(EventPumpStatusChanged.Status.CONNECTED))
+ rxBus.send(EventRefreshOverview("Carelevo connection state", true))
+ rxBus.send(EventCustomActionsChanged())
+ }
+
+ is PatchState.NotConnectedBooted -> {
+ aapsLogger.debug(LTag.PUMPCOMM, "patch state is NotConnectedBooted")
+ }
+
+ else -> {
+ aapsLogger.debug(LTag.PUMPCOMM, "patch state is disconnected")
+ rxBus.send(EventPumpStatusChanged(EventPumpStatusChanged.Status.DISCONNECTED))
+ }
+ }
+
+ result
+ }
+ .observeOn(aapsSchedulers.io)
+ .subscribeOn(aapsSchedulers.io)
+ .doOnComplete {
+ aapsLogger.debug(LTag.PUMPCOMM, "doOnComplete called")
+ }
+ .doOnError {
+ it.printStackTrace()
+ aapsLogger.debug(LTag.PUMPCOMM, "doOnError called : $it")
+ }
+ .subscribe {
+ aapsLogger.debug(LTag.PUMPCOMM, "result : $it")
+ }
+ }
+
+ fun isBluetoothEnabled(): Boolean {
+ return btState.value?.getOrNull()?.let {
+ it.isEnabled == DeviceModuleState.DEVICE_STATE_ON
+ } ?: false
+ }
+
+ //===================================================================================================
+ fun setProfile(profile: Profile?) {
+ _profile.onNext(Optional.ofNullable(profile))
+ }
+
+ fun checkIsSameProfile(newProfile: Profile?): Boolean {
+ val setProfile = profile.value?.getOrNull() ?: return false
+ val a = newProfile ?: return false
+ val aVals = a.getBasalValues()
+ val bVals = setProfile.getBasalValues()
+
+ if (aVals.size != bVals.size) return false
+
+ for (i in aVals.indices) {
+ if (TimeUnit.SECONDS.toMinutes(aVals[i].timeAsSeconds.toLong()) !=
+ TimeUnit.SECONDS.toMinutes(bVals[i].timeAsSeconds.toLong())
+ ) return false
+
+ if (!nearlyEqual(aVals[i].value.toFloat(), bVals[i].value.toFloat())) return false
+ }
+ return true
+ }
+
+ private fun nearlyEqual(a: Float, b: Float, epsilon: Float = 1e-3f): Boolean {
+ val absA = abs(a)
+ val absB = abs(b)
+ val diff = abs(a - b)
+ return if (a == b) {
+ true
+ } else if (a == 0f || b == 0f || absA + absB < java.lang.Float.MIN_NORMAL) {
+ diff < epsilon * java.lang.Float.MIN_NORMAL
+ } else {
+ diff / min(absA + absB, Float.MAX_VALUE) < epsilon
+ }
+ }
+
+ /**
+ * btState source: the plugin's Bluetooth broadcast receiver (adapter on/off) plus its startup
+ * seed. Raises the Bluetooth-off alarm on the ON→OFF edge.
+ */
+ fun onBluetoothStateChanged(state: BleState) {
+ aapsLogger.debug(LTag.PUMPCOMM, "btState : $state")
+ if (state.isEnabled == DeviceModuleState.DEVICE_STATE_OFF &&
+ lastBtState != null && lastBtState?.isEnabled != DeviceModuleState.DEVICE_STATE_OFF
+ ) {
+ handleAlarm("alert", value = null, cause = AlarmCause.ALARM_ALERT_BLUETOOTH_OFF)
+ }
+ lastBtState = state
+ _btState.onNext(Optional.of(state))
+ }
+
+ fun releasePatch() {
+ flushPatchInformation()
+ }
+
+ fun flushPatchInformation() {
+ // Clear cached patch/infusion info. This resets isCheckScreen (which otherwise keeps the
+ // wizard latched to SAFETY_CHECK after a mid-activation discard) and immediately drops
+ // patchState to NotConnectedNotBooting. There is no resting GATT to tear down — sessions are per-op.
+ _patchInfo.onNext(Optional.empty())
+ _infusionInfo.onNext(Optional.empty())
+ }
+
+ private val discardInProgress = AtomicBoolean(false)
+
+ /**
+ * Full BLE teardown for a discarded patch: remove the OS bond, then [releasePatch] (clear cached
+ * patch info). Single-flight — if a teardown is already running (e.g. a queued CmdDiscard racing
+ * the ViewModel force-discard fallback), the second caller is skipped. Self-contained: swallows
+ * teardown errors, so callers report the already-decided discard result unaffected.
+ */
+ fun discardTeardown() {
+ if (!discardInProgress.compareAndSet(false, true)) {
+ aapsLogger.debug(LTag.PUMPCOMM, "discardTeardown skipped (already in progress)")
+ return
+ }
+ // Unbond and flush independently: a failed unbond (adapter gone, bond already removed)
+ // must never leave the discarded patch's cached info behind — a stale record would keep
+ // patchState at ConnectedBooted and re-latch the wizard's check screens.
+ try {
+ getPatchInfoAddress()?.let { transport.adapter.removeBond(it.uppercase()) }
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "discardTeardown unbond error", e)
+ }
+ try {
+ releasePatch()
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "discardTeardown release error", e)
+ } finally {
+ discardInProgress.set(false)
+ }
+ }
+
+ /**
+ * Persist an infusion-info report decoded by the [app.aaps.pump.carelevo.ble.BleClient] stack.
+ * [pumpStateRaw]/[modeRaw] are the raw 0x91 bytes; they are normalized through the
+ * `codeTo…().commandToCode()` round-trip the persisted codes require, so the persisted values
+ * are byte-for-byte identical to a full decode.
+ */
+ fun applyInfusionInfoReport(
+ runningMinutes: Int,
+ remains: Double,
+ infusedTotalBasalAmount: Double,
+ infusedTotalBolusAmount: Double,
+ pumpStateRaw: Int,
+ modeRaw: Int
+ ) {
+ dispatchInfusionInfo(
+ CarelevoPatchRptInfusionInfoRequestModel(
+ runningMinute = runningMinutes,
+ remains = remains,
+ infusedTotalBasalAmount = infusedTotalBasalAmount,
+ infusedTotalBolusAmount = infusedTotalBolusAmount,
+ pumpState = pumpStateRaw.codeToPumpStateCommand().commandToCode(),
+ mode = modeRaw.codeToInfusionModeCommand().commandToCode(),
+ currentInfusedProgramVolume = 0.0, // not persisted by the process use case
+ realInfusedTime = 0
+ )
+ )
+ }
+
+ private fun dispatchInfusionInfo(requestModel: CarelevoPatchRptInfusionInfoRequestModel) {
+ bleDisposable += patchRptInfusionInfoProcessUseCase.execute(requestModel)
+ .timeout(3, TimeUnit.SECONDS)
+ .observeOn(aapsSchedulers.io)
+ .subscribeOn(aapsSchedulers.io)
+ .subscribe()
+ }
+
+ /**
+ * Raise a patch alarm locally (alarm DB + notifier pipeline). Public seam: the long-lived
+ * `unsolicitedEvents` bridge feeds pump-pushed alert/warning/notice frames here; today it is
+ * used for the Bluetooth-off alert.
+ */
+ fun handleAlarm(modelType: String, value: Int?, cause: AlarmCause) {
+ aapsLogger.debug(LTag.PUMPCOMM, "$modelType report : $value, $cause")
+ val info = CarelevoAlarmInfo(
+ // UUID, not a millisecond timestamp — two alarms raised in the same millisecond (rapid
+ // BLE flapping) would otherwise collide and one would silently overwrite the other.
+ alarmId = UUID.randomUUID().toString(),
+ alarmType = cause.alarmType,
+ cause = cause,
+ value = value,
+ createdAt = LocalDateTime.now().toString(),
+ updatedAt = LocalDateTime.now().toString(),
+ isAcknowledged = false
+ )
+ bleDisposable += carelevoAlarmInfoUseCase.upsertAlarm(info)
+ .subscribeOn(aapsSchedulers.io)
+ .observeOn(aapsSchedulers.main)
+ .subscribe(
+ { aapsLogger.debug(LTag.PUMPCOMM, "handleAlarm upsert complete") },
+ { e -> aapsLogger.error(LTag.PUMPCOMM, "handleAlarm upsert error", e) }
+ )
+ }
+
+ /**
+ * Reconcile local state to "resumed" after a timed pump-stop ends. The patch auto-resumes at the stop
+ * duration, but with per-op sessions there is no live link to receive its stop-report push, and a 0x91
+ * status read does not carry the suspend flag (see `CarelevoPatchRptInfusionInfoProcessUseCase`) — so
+ * without this, [CarelevoPatchInfoDomainModel.isStopped] would stay latched until an app-initiated
+ * resume. Called by the plugin's expiry watchdog and by [onUnsolicited] when a stop/basal-restart
+ * report is caught mid-session. Repository writes are synchronous, so callers invoke it off the main
+ * thread. Idempotent — a no-op when the pump is already running.
+ */
+ fun reconcileAutoResumed() {
+ // Only act when the pump is currently marked stopped — there is nothing to resume otherwise. This
+ // guards against a basal-restart report (0x88) that fires during normal delivery, or that races a
+ // stop command: an unconditional persistResumed would clear a legitimate suspend.
+ if (patchInfo.value?.getOrNull()?.isStopped != true) {
+ aapsLogger.debug(LTag.PUMPCOMM, "auto-resume reconcile skipped: pump not stopped")
+ return
+ }
+ val ok = pumpResumeUseCase.persistResumed()
+ aapsLogger.info(LTag.PUMPCOMM, "auto-resume reconcile: persistResumed=$ok")
+ if (!ok) return
+ rxBus.send(EventPumpStatusChanged(EventPumpStatusChanged.Status.CONNECTED))
+ rxBus.send(EventRefreshOverview("Carelevo auto-resume", true))
+ }
+
+ /**
+ * Route a patch-pushed [UnsolicitedMessage] (a notification that matched no in-flight request) by
+ * opcode — the bridge the BLE migration dropped. Stop-report (0x8A) / basal-restart (0x88) reconcile
+ * the resumed state; warning/alert/notice pushes (0xA1/0xA2/0xA3) decode to an [AlarmCause] and raise
+ * the alarm, reusing the pre-migration mapping. Runs on the session's IO scope and must NOT start a new
+ * BLE session (the session mutex is held for the whole call — a nested session self-deadlocks);
+ * [reconcileAutoResumed] and [handleAlarm] only persist, so this is safe.
+ */
+ fun onUnsolicited(msg: UnsolicitedMessage) {
+ when (msg.opcode) {
+ RPT_PUMP_STOP, RPT_BASAL_RESTART -> {
+ aapsLogger.info(LTag.PUMPCOMM, "unsolicited resume report ${hex(msg.opcode)} -> reconcile")
+ reconcileAutoResumed()
+ }
+
+ RPT_WARNING -> raiseAlarm("warning", AlarmType.WARNING, msg.payload)
+ RPT_ALERT -> raiseAlarm("alert", AlarmType.ALERT, msg.payload)
+ RPT_NOTICE -> raiseAlarm("notice", AlarmType.NOTICE, msg.payload)
+
+ else ->
+ aapsLogger.debug(LTag.PUMPCOMM, "unsolicited frame ${hex(msg.opcode)} (${msg.payload.size}B) unhandled")
+ }
+ }
+
+ /** Decode a pushed alarm frame `[opcode][cause][value]` to an [AlarmCause] and raise it via [handleAlarm]. */
+ private fun raiseAlarm(modelType: String, type: AlarmType, payload: ByteArray) {
+ val causeCode = payload.getOrNull(1)?.toUByte()?.toInt()
+ val value = payload.getOrNull(2)?.toUByte()?.toInt()
+ handleAlarm(modelType, value, AlarmCause.fromTypeAndCode(type, causeCode))
+ }
+
+ private fun observeInfusionInfo() {
+ infoDisposable += infusionInfoMonitorUseCase.execute()
+ .subscribeOn(aapsSchedulers.io)
+ .observeOn(aapsSchedulers.main)
+ .subscribe { response ->
+ when (response) {
+ is ResponseResult.Success -> {
+ val result = response.data as CarelevoInfusionInfoDomainModel?
+ aapsLogger.debug(LTag.PUMPCOMM, "response success result ==> $result")
+ _infusionInfo.onNext(Optional.ofNullable(result))
+ }
+
+ is ResponseResult.Error -> {
+ aapsLogger.error(LTag.PUMPCOMM, "response error : ${response.e}")
+ }
+
+ else -> {
+ aapsLogger.error(LTag.PUMPCOMM, "response failed")
+ }
+ }
+ }
+ }
+
+ private fun observePatchInfo() {
+ infoDisposable += patchInfoMonitorUseCase.execute()
+ .subscribeOn(aapsSchedulers.io)
+ .observeOn(aapsSchedulers.io)
+ .subscribe { response ->
+ when (response) {
+ is ResponseResult.Success -> {
+ val result = response.data as CarelevoPatchInfoDomainModel?
+ aapsLogger.debug(LTag.PUMPCOMM, "response success result ==> ${result?.needleFailedCount}")
+ _patchInfo.onNext(Optional.ofNullable(result))
+ }
+
+ is ResponseResult.Error -> {
+ aapsLogger.debug(LTag.PUMPCOMM, "response error : ${response.e}")
+ }
+
+ else -> {
+ aapsLogger.debug(LTag.PUMPCOMM, "response failed")
+ }
+ }
+ }
+ }
+
+ private fun observeUserSettingInfo() {
+ infoDisposable += userSettingInfoMonitorUseCase.execute()
+ .subscribeOn(aapsSchedulers.io)
+ .observeOn(aapsSchedulers.main)
+ .subscribe { response ->
+ when (response) {
+ is ResponseResult.Success -> {
+ val result = response.data as CarelevoUserSettingInfoDomainModel?
+ aapsLogger.debug(LTag.PUMPCOMM, "response success result ==> $result")
+ _userSettingInfo.onNext(Optional.ofNullable(result))
+ if (result == null) {
+ createUserSettingInfo()
+ }
+ }
+
+ is ResponseResult.Error -> {
+ aapsLogger.error(LTag.PUMPCOMM, "response error : ${response.e}")
+ }
+
+ else -> {
+ aapsLogger.error(LTag.PUMPCOMM, "response failed")
+ }
+ }
+ }
+ }
+
+ private fun createUserSettingInfo() {
+ // Read prefs + build the request on IO: createUserSettingInfo() runs from observeUserSettingInfo's
+ // Main-thread subscribe, and SharedPreferences reads on the main thread risk an ANR.
+ infoDisposable += Single.fromCallable {
+ CarelevoUserSettingInfoRequestModel(
+ lowInsulinNoticeAmount = sp.getInt(CarelevoIntPreferenceKey.CARELEVO_LOW_INSULIN_EXPIRATION_REMINDER_HOURS.key, 30),
+ maxBasalSpeed = 15.0,
+ maxBolusDose = preferences.get(DoubleKey.SafetyMaxBolus)
+ )
+ }
+ .subscribeOn(aapsSchedulers.io)
+ .flatMap { createUserSettingInfoUseCase.execute(it) }
+ .subscribe()
+ }
+
+ private companion object {
+
+ // Unsolicited report opcodes (byte 0). Stop/basal-restart are the auto-resume signals; the
+ // 0xA1/0xA2/0xA3 message reports are the pushed alarms (severity tier via AlarmType).
+ private const val RPT_BASAL_RESTART: Byte = 0x88.toByte() // CMD_BASAL_RESTART_RPT
+ private const val RPT_PUMP_STOP: Byte = 0x8A.toByte() // CMD_PUMP_STOP_RPT (stop window ended)
+ private const val RPT_WARNING: Byte = 0xA1.toByte() // CMD_WARNING_MSG_RPT
+ private const val RPT_ALERT: Byte = 0xA2.toByte() // CMD_ALERT_MSG_RPT
+ private const val RPT_NOTICE: Byte = 0xA3.toByte() // CMD_NOTICE_MSG_RPT
+
+ private fun hex(b: Byte) = "0x%02X".format(b.toInt() and 0xFF)
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoReceiverDisposable.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoReceiverDisposable.kt
new file mode 100644
index 000000000000..87a35f568e1b
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/CarelevoReceiverDisposable.kt
@@ -0,0 +1,29 @@
+package app.aaps.pump.carelevo.common
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import io.reactivex.rxjava3.disposables.Disposable
+
+/**
+ * Rx [Disposable] that unregisters [receiver] on dispose — the teardown half of
+ * [CarelevoObserveReceiver]'s register-on-subscribe, preventing the classic leaked-receiver bug
+ * when the plugin's subscription is cleared in `onStop()`.
+ */
+class CarelevoReceiverDisposable(
+ private val context: Context,
+ private val receiver: BroadcastReceiver
+) : Disposable {
+
+ private var isDisposed = false
+
+ @Synchronized
+ override fun dispose() {
+ context.unregisterReceiver(receiver)
+ isDisposed = true
+ }
+
+ @Synchronized
+ override fun isDisposed(): Boolean {
+ return isDisposed
+ }
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/keys/CarelevoBooleanPreferenceKey.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/keys/CarelevoBooleanPreferenceKey.kt
new file mode 100644
index 000000000000..d103bdf44a3f
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/keys/CarelevoBooleanPreferenceKey.kt
@@ -0,0 +1,24 @@
+package app.aaps.pump.carelevo.common.keys
+
+import app.aaps.core.keys.interfaces.BooleanPreferenceKey
+import app.aaps.pump.carelevo.R
+
+enum class CarelevoBooleanPreferenceKey(
+ override val key: String,
+ override val defaultValue: Boolean,
+ override val titleResId: Int = 0,
+ override val calculatedDefaultValue: Boolean = false,
+ override val engineeringModeOnly: Boolean = false,
+ override val defaultedBySM: Boolean = false,
+ override val showInApsMode: Boolean = true,
+ override val showInNsClientMode: Boolean = true,
+ override val showInPumpControlMode: Boolean = true,
+ override val dependency: BooleanPreferenceKey? = null,
+ override val negativeDependency: BooleanPreferenceKey? = null,
+ override val hideParentScreenIfHidden: Boolean = false,
+ override val exportable: Boolean = true
+) : BooleanPreferenceKey {
+
+ CARELEVO_BUZZER_REMINDER(key = "CARELEVO_BUZZER_REMINDER", defaultValue = false, titleResId = R.string.carelevo_patch_buzzer_alarm_title),
+ CARELEVO_CAGE_DEFAULT_APPLIED(key = "carelevo_cage_default_applied", defaultValue = false, titleResId = 0),
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/keys/CarelevoIntPreferenceKey.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/keys/CarelevoIntPreferenceKey.kt
new file mode 100644
index 000000000000..98d063659be6
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/keys/CarelevoIntPreferenceKey.kt
@@ -0,0 +1,40 @@
+package app.aaps.pump.carelevo.common.keys
+
+import app.aaps.core.keys.PreferenceType
+import app.aaps.core.keys.interfaces.BooleanPreferenceKey
+import app.aaps.core.keys.interfaces.IntPreferenceKey
+import app.aaps.pump.carelevo.R
+
+enum class CarelevoIntPreferenceKey(
+ override val key: String,
+ override val defaultValue: Int,
+ override val titleResId: Int = 0,
+ override val min: Int = Int.MIN_VALUE,
+ override val max: Int = Int.MAX_VALUE,
+ override val preferenceType: PreferenceType = PreferenceType.TEXT_FIELD,
+ override val entries: Map = emptyMap(),
+ override val calculatedDefaultValue: Boolean = false,
+ override val engineeringModeOnly: Boolean = false,
+ override val defaultedBySM: Boolean = false,
+ override val showInApsMode: Boolean = true,
+ override val showInNsClientMode: Boolean = true,
+ override val showInPumpControlMode: Boolean = true,
+ override val dependency: BooleanPreferenceKey? = null,
+ override val negativeDependency: BooleanPreferenceKey? = null,
+ override val hideParentScreenIfHidden: Boolean = false,
+ override val exportable: Boolean = true
+) : IntPreferenceKey {
+
+ CARELEVO_PATCH_EXPIRATION_REMINDER_HOURS(
+ "CARELEVO_PATCH_EXPIRATION_REMINDER_HOURS",
+ 116,
+ R.string.carelevo_patch_expiration_reminders_title_value,
+ preferenceType = PreferenceType.LIST
+ ),
+ CARELEVO_LOW_INSULIN_EXPIRATION_REMINDER_HOURS(
+ "CARELEVO_LOW_INSULIN_EXPIRATION_REMINDER_HOURS",
+ 30,
+ R.string.carelevo_low_reservoir_reminders_title_value,
+ preferenceType = PreferenceType.LIST
+ )
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/model/CarelevoEvent.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/model/CarelevoEvent.kt
new file mode 100644
index 000000000000..d0c84d92492f
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/model/CarelevoEvent.kt
@@ -0,0 +1,8 @@
+package app.aaps.pump.carelevo.common.model
+
+/**
+ * Marker for one-shot UI events delivered through
+ * [app.aaps.pump.carelevo.common.MutableEventFlow] (consumed exactly once per emission) — e.g.
+ * the `CarelevoOverviewEvent`/`AlarmEvent` hierarchies in `presentation.model`.
+ */
+interface Event
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/model/CarelevoState.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/model/CarelevoState.kt
new file mode 100644
index 000000000000..8452e748796c
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/common/model/CarelevoState.kt
@@ -0,0 +1,33 @@
+package app.aaps.pump.carelevo.common.model
+
+/** Marker for observable state values exposed by ViewModels/singletons (vs one-shot [Event]s). */
+interface State
+
+/** Generic busy indicator for screens that show a blocking progress overlay during BLE ops. */
+sealed class UiState : State {
+ data object Idle : UiState()
+ data object Loading : UiState()
+}
+
+/**
+ * Coarse patch lifecycle derived in `CarelevoPatch.resolvePatchState` from the persisted patch
+ * record ("booted" = activation completed) + live BLE link state. Drives which overview/wizard
+ * surface is shown.
+ */
+sealed interface PatchState {
+
+ data object NotConnectedNotBooting : PatchState
+ data object NotConnectedBooted : PatchState
+ data object ConnectedNoBooted : PatchState
+ data object ConnectedBooted : PatchState
+
+}
+
+/** Delivery run-state of the pump as last reported by the patch (idle/delivering/suspended). */
+sealed interface PumpState {
+
+ data object Idle : PumpState
+ data object Start : PumpState
+ data object Stop : PumpState
+
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/CarelevoComposeContent.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/CarelevoComposeContent.kt
new file mode 100644
index 000000000000..7a5c0f93312c
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/CarelevoComposeContent.kt
@@ -0,0 +1,177 @@
+package app.aaps.pump.carelevo.compose
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.res.stringResource
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.aaps.core.interfaces.configuration.Config
+import app.aaps.core.interfaces.configuration.ExternalOptions
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.core.ui.compose.LocalSnackbarHostState
+import app.aaps.core.interfaces.protection.ProtectionCheck
+import app.aaps.core.interfaces.protection.ProtectionResult
+import app.aaps.core.interfaces.pump.BlePreCheck
+import app.aaps.core.interfaces.ui.IconsProvider
+import app.aaps.core.ui.compose.ComposablePluginContent
+import app.aaps.core.ui.compose.ToolbarConfig
+import app.aaps.core.ui.compose.pump.BlePreCheckHost
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.common.CarelevoAlarmNotifier
+import app.aaps.pump.carelevo.compose.alarm.CarelevoAlarmHost
+import app.aaps.pump.carelevo.compose.patchflow.CarelevoPatchFlowScreen
+import app.aaps.pump.carelevo.presentation.type.CarelevoScreenType
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoOverviewViewModel
+
+class CarelevoComposeContent(
+ private val aapsLogger: AAPSLogger,
+ private val carelevoAlarmNotifier: CarelevoAlarmNotifier,
+ private val protectionCheck: ProtectionCheck,
+ private val blePreCheck: BlePreCheck,
+ private val iconsProvider: IconsProvider,
+ private val config: Config
+) : ComposablePluginContent {
+
+ /**
+ * The emulated patch has no radio behind it, so the real BLE readiness check would fail the
+ * activation flow before it starts. Mirrors `DanaRSPairWizardViewModel.isEmulating`.
+ */
+ private val isEmulating: Boolean get() = config.isEnabled(ExternalOptions.EMULATE_CARELEVO)
+
+ @Composable
+ override fun Render(
+ setToolbarConfig: (ToolbarConfig) -> Unit,
+ onNavigateBack: () -> Unit,
+ onSettings: (() -> Unit)?
+ ) {
+ val overviewViewModel: CarelevoOverviewViewModel = hiltViewModel()
+ // Single place this module reads the app-provided CompositionLocal — children get it as an
+ // explicit parameter (preferred pattern; do not add new .current consumers below).
+ val snackbarHostState = LocalSnackbarHostState.current
+ val overviewNavIcon: @Composable () -> Unit = {
+ IconButton(onClick = onNavigateBack) {
+ Icon(
+ Icons.AutoMirrored.Filled.ArrowBack,
+ contentDescription = stringResource(CoreUiR.string.back)
+ )
+ }
+ }
+ val settingsAction: @Composable RowScope.() -> Unit = {
+ onSettings?.let { action ->
+ IconButton(onClick = action) {
+ Icon(
+ Icons.Filled.Settings,
+ contentDescription = stringResource(CoreUiR.string.settings)
+ )
+ }
+ }
+ }
+
+ var manualWorkflowScreen by remember { mutableStateOf(null) }
+ var latchedWorkflowScreen by remember { mutableStateOf(null) }
+ val checkScreen by overviewViewModel.isCheckScreen.collectAsStateWithLifecycle()
+ val activeWorkflowScreen = manualWorkflowScreen ?: latchedWorkflowScreen ?: checkScreen
+ val pluginName = stringResource(R.string.carelevo)
+
+ LaunchedEffect(checkScreen, manualWorkflowScreen) {
+ if (manualWorkflowScreen == null) {
+ when (checkScreen) {
+ CarelevoScreenType.SAFETY_CHECK,
+ CarelevoScreenType.NEEDLE_INSERTION -> latchedWorkflowScreen = checkScreen
+
+ null -> Unit
+ else -> latchedWorkflowScreen = null
+ }
+ }
+ }
+
+ LaunchedEffect(activeWorkflowScreen, pluginName) {
+ if (activeWorkflowScreen == null) {
+ setToolbarConfig(
+ ToolbarConfig(
+ title = pluginName,
+ navigationIcon = overviewNavIcon,
+ actions = settingsAction
+ )
+ )
+ }
+ }
+
+ val startWorkflow: (CarelevoScreenType) -> Unit = remember(protectionCheck) {
+ { screenType ->
+ if (screenType == CarelevoScreenType.CONNECTION_FLOW_START) {
+ protectionCheck.requestProtection(ProtectionCheck.Protection.PREFERENCES) { result ->
+ if (result == ProtectionResult.GRANTED) {
+ manualWorkflowScreen = screenType
+ latchedWorkflowScreen = null
+ }
+ }
+ } else {
+ manualWorkflowScreen = screenType
+ latchedWorkflowScreen = null
+ }
+ }
+ }
+
+ Box {
+ when (activeWorkflowScreen) {
+ null -> {
+ CarelevoOverviewScreen(
+ viewModel = overviewViewModel,
+ snackbarHostState = snackbarHostState,
+ onStartWorkflow = startWorkflow
+ )
+ }
+
+ CarelevoScreenType.CONNECTION_FLOW_START -> {
+ if (!isEmulating) {
+ BlePreCheckHost(
+ blePreCheck = blePreCheck,
+ onFailed = { manualWorkflowScreen = null }
+ )
+ }
+ CarelevoPatchFlowScreen(
+ screenType = activeWorkflowScreen,
+ setToolbarConfig = setToolbarConfig,
+ snackbarHostState = snackbarHostState,
+ onExitFlow = {
+ manualWorkflowScreen = null
+ latchedWorkflowScreen = null
+ }
+ )
+ }
+
+ else -> {
+ CarelevoPatchFlowScreen(
+ screenType = activeWorkflowScreen,
+ setToolbarConfig = setToolbarConfig,
+ snackbarHostState = snackbarHostState,
+ onExitFlow = {
+ manualWorkflowScreen = null
+ latchedWorkflowScreen = null
+ }
+ )
+ }
+ }
+
+ CarelevoAlarmHost(
+ aapsLogger = aapsLogger,
+ carelevoAlarmNotifier = carelevoAlarmNotifier,
+ iconsProvider = iconsProvider,
+ snackbarHostState = snackbarHostState
+ )
+ }
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/CarelevoOverviewScreen.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/CarelevoOverviewScreen.kt
new file mode 100644
index 000000000000..e156b7bb43ef
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/CarelevoOverviewScreen.kt
@@ -0,0 +1,320 @@
+package app.aaps.pump.carelevo.compose
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.SwapHoriz
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.core.ui.compose.StatusLevel
+import app.aaps.core.ui.compose.icons.IcLoopPaused
+import app.aaps.core.ui.compose.pump.ActionCategory
+import app.aaps.core.ui.compose.pump.PumpAction
+import app.aaps.core.ui.compose.pump.PumpInfoRow
+import app.aaps.core.ui.compose.pump.PumpOverviewScreen
+import app.aaps.core.ui.compose.pump.PumpOverviewUiState
+import app.aaps.core.ui.compose.pump.StatusBanner
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.common.model.UiState
+import app.aaps.pump.carelevo.compose.dialog.CarelevoActionDialog
+import app.aaps.pump.carelevo.compose.dialog.CarelevoPumpStopDurationDialog
+import app.aaps.pump.carelevo.presentation.model.CarelevoOverviewEvent
+import app.aaps.pump.carelevo.presentation.type.CarelevoScreenType
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoOverviewViewModel
+
+@Composable
+internal fun CarelevoOverviewScreen(
+ viewModel: CarelevoOverviewViewModel,
+ snackbarHostState: SnackbarHostState,
+ onStartWorkflow: (CarelevoScreenType) -> Unit
+) {
+ val baseState by viewModel.overviewUiState.collectAsStateWithLifecycle()
+ val actionState by viewModel.uiState.collectAsStateWithLifecycle()
+
+ var showDiscardDialog by remember { mutableStateOf(false) }
+ var showResumeDialog by remember { mutableStateOf(false) }
+ var showSuspendTimePicker by remember { mutableStateOf(false) }
+ var selectedDurationIndex by remember { mutableIntStateOf(0) }
+
+ val stopDurations = remember { listOf(30, 60, 90, 120, 150, 180, 210, 240) }
+ val stopDurationLabels = listOf(
+ stringResource(R.string.carelevo_pump_stop_duration_label_30_min),
+ stringResource(R.string.carelevo_pump_stop_duration_label_1_hour),
+ stringResource(R.string.carelevo_pump_stop_duration_label_1_hour_30_min),
+ stringResource(R.string.carelevo_pump_stop_duration_label_2_hour),
+ stringResource(R.string.carelevo_pump_stop_duration_label_2_hour_30_min),
+ stringResource(R.string.carelevo_pump_stop_duration_label_3_hour),
+ stringResource(R.string.carelevo_pump_stop_duration_label_3_hour_30_min),
+ stringResource(R.string.carelevo_pump_stop_duration_label_4_hour),
+ )
+ val bluetoothNotEnabledMessage = stringResource(R.string.carelevo_toast_msg_bluetooth_not_enabled)
+ val notConnectedMessage = stringResource(R.string.carelevo_toast_msg_patch_not_connected)
+ val discardFailedMessage = stringResource(R.string.carelevo_toast_msg_discard_failed)
+ val resumeFailedMessage = stringResource(R.string.carelevo_toast_mag_set_basal_resume_fail)
+ val suspendFailedMessage = stringResource(R.string.carelevo_toast_mag_set_basal_suspend_fail)
+ val isActionLoading = actionState is UiState.Loading
+
+ LaunchedEffect(viewModel) {
+ if (!viewModel.isCreated) {
+ viewModel.observePatchInfo()
+ viewModel.observePatchState()
+ viewModel.observeInfusionInfo()
+ viewModel.observeProfile()
+ viewModel.setIsCreated(true)
+ }
+ viewModel.refreshPatchInfusionInfo()
+ }
+
+ LaunchedEffect(viewModel) {
+ viewModel.event.collect { event ->
+ when (event) {
+ CarelevoOverviewEvent.ShowMessageBluetoothNotEnabled -> snackbarHostState.showSnackbar(bluetoothNotEnabledMessage)
+ CarelevoOverviewEvent.ShowMessageCarelevoIsNotConnected -> snackbarHostState.showSnackbar(notConnectedMessage)
+ CarelevoOverviewEvent.DiscardFailed -> snackbarHostState.showSnackbar(discardFailedMessage)
+ CarelevoOverviewEvent.ResumePumpFailed -> snackbarHostState.showSnackbar(resumeFailedMessage)
+ CarelevoOverviewEvent.StopPumpFailed -> snackbarHostState.showSnackbar(suspendFailedMessage)
+ CarelevoOverviewEvent.ShowPumpResumeDialog -> showResumeDialog = true
+ CarelevoOverviewEvent.ShowPumpStopDurationSelectDialog -> showSuspendTimePicker = true
+ CarelevoOverviewEvent.StartConnectionFlow -> onStartWorkflow(CarelevoScreenType.CONNECTION_FLOW_START)
+ CarelevoOverviewEvent.ShowPumpDiscardDialog -> showDiscardDialog = true
+ CarelevoOverviewEvent.ClickPumpStopResumeBtn,
+ CarelevoOverviewEvent.NoAction -> Unit
+ }
+ }
+ }
+
+ if (showDiscardDialog) {
+ CarelevoActionDialog(
+ title = stringResource(R.string.carelevo_dialog_patch_discard_message_title),
+ content = stringResource(R.string.carelevo_dialog_patch_discard_message_desc),
+ onDismissRequest = { showDiscardDialog = false },
+ primaryText = stringResource(R.string.carelevo_btn_confirm),
+ onPrimaryClick = {
+ showDiscardDialog = false
+ viewModel.startDiscardProcess()
+ },
+ secondaryText = stringResource(R.string.carelevo_btn_cancel),
+ onSecondaryClick = { showDiscardDialog = false }
+ )
+ }
+
+ if (showResumeDialog) {
+ CarelevoActionDialog(
+ title = stringResource(R.string.carelevo_pump_resume_title),
+ content = stringResource(R.string.carelevo_pump_resume_description),
+ onDismissRequest = { showResumeDialog = false },
+ primaryText = stringResource(R.string.carelevo_btn_confirm),
+ onPrimaryClick = {
+ showResumeDialog = false
+ viewModel.startPumpResume()
+ },
+ secondaryText = stringResource(R.string.carelevo_btn_cancel),
+ onSecondaryClick = { showResumeDialog = false }
+ )
+ }
+
+ if (showSuspendTimePicker) {
+ CarelevoPumpStopDurationDialog(
+ options = stopDurations,
+ labels = stopDurationLabels,
+ initialIndex = selectedDurationIndex,
+ onDismissRequest = {
+ showSuspendTimePicker = false
+ selectedDurationIndex = 0
+ },
+ onConfirm = { duration ->
+ showSuspendTimePicker = false
+ viewModel.startPumpStopProcess(duration)
+ selectedDurationIndex = 0
+ }
+ )
+ }
+
+ Box {
+ PumpOverviewScreen(
+ state = baseState,
+ customContent = {
+ Image(
+ painter = painterResource(id = R.drawable.ic_carelevo_128),
+ contentDescription = null,
+ modifier = Modifier
+ .fillMaxWidth()
+ .height(128.dp),
+ contentScale = ContentScale.Fit
+ )
+ }
+ )
+
+ if (isActionLoading) {
+ Box(
+ modifier = Modifier
+ .fillMaxSize()
+ .background(MaterialTheme.colorScheme.scrim.copy(alpha = 0.32f))
+ // Consume all taps so an in-flight discard/suspend/resume can't be re-fired
+ // by a second tap on the action underneath.
+ .pointerInput(Unit) { detectTapGestures { } },
+ contentAlignment = Alignment.Center
+ ) {
+ Column(horizontalAlignment = Alignment.CenterHorizontally) {
+ CircularProgressIndicator(color = MaterialTheme.colorScheme.primary)
+ Text(
+ text = stringResource(CoreUiR.string.loading),
+ color = MaterialTheme.colorScheme.onSurface,
+ style = MaterialTheme.typography.bodyLarge
+ )
+ }
+ }
+ }
+ }
+}
+
+@Preview(showBackground = true, name = "Carelevo Overview Connected")
+@Composable
+private fun CarelevoOverviewScreenConnectedPreview() {
+ MaterialTheme {
+ PumpOverviewScreen(
+ state = PumpOverviewUiState(
+ statusBanner = StatusBanner(
+ text = stringResource(R.string.carelevo_state_connected_value),
+ level = StatusLevel.NORMAL
+ ),
+ infoRows = listOf(
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_bluetooth_state_key),
+ value = stringResource(R.string.carelevo_state_connected_value)
+ ),
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_serial_number_key),
+ value = "04:CD:15:D0:10:05"
+ ),
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_firmware_version_key),
+ value = "T165"
+ ),
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_boot_date_time_key),
+ value = "2026-04-13 09:00"
+ ),
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_expiration_key),
+ value = "2026-04-20 09:00"
+ ),
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_running_remain_time),
+ value = "2d 11h 20m"
+ ),
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_basal_rate_key),
+ value = stringResource(R.string.common_label_unit_value_dose_per_speed_with_space, 1.2)
+ ),
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_temp_basal_rate_key),
+ value = stringResource(R.string.common_label_unit_value_dose_per_speed_with_space, 0.5)
+ ),
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_insulin_remain_key),
+ value = "298.0 U"
+ ),
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_total_insulin_key),
+ value = stringResource(R.string.common_label_unit_value_dose_with_space, "12.50")
+ )
+ ),
+ primaryActions = emptyList(),
+ managementActions = listOf(
+ PumpAction(
+ label = stringResource(R.string.carelevo_overview_pump_discard_btn_label),
+ icon = Icons.Filled.Delete,
+ category = ActionCategory.MANAGEMENT,
+ enabled = true,
+ visible = true,
+ onClick = {}
+ ),
+ PumpAction(
+ label = stringResource(CoreUiR.string.pump_suspend),
+ icon = IcLoopPaused,
+ category = ActionCategory.MANAGEMENT,
+ enabled = true,
+ visible = true,
+ onClick = {}
+ )
+ )
+ ),
+ customContent = {
+ Image(
+ painter = painterResource(id = R.drawable.ic_carelevo_128),
+ contentDescription = null,
+ modifier = Modifier
+ .fillMaxWidth()
+ .height(128.dp),
+ contentScale = ContentScale.Fit
+ )
+ }
+ )
+ }
+}
+
+@Preview(showBackground = true, name = "Carelevo Overview Disconnected")
+@Composable
+private fun CarelevoOverviewScreenDisconnectedPreview() {
+ MaterialTheme {
+ PumpOverviewScreen(
+ state = PumpOverviewUiState(
+ statusBanner = StatusBanner(
+ text = stringResource(R.string.carelevo_state_none_value),
+ level = StatusLevel.WARNING
+ ),
+ infoRows = listOf(
+ PumpInfoRow(
+ label = stringResource(R.string.carelevo_bluetooth_state_key),
+ value = stringResource(R.string.carelevo_state_disconnected_value)
+ )
+ ),
+ primaryActions = listOf(
+ PumpAction(
+ label = stringResource(R.string.carelevo_overview_connect_btn_label),
+ icon = Icons.Filled.SwapHoriz,
+ enabled = true,
+ onClick = {}
+ )
+ )
+ ),
+ customContent = {
+ Image(
+ painter = painterResource(id = R.drawable.ic_carelevo_128),
+ contentDescription = null,
+ modifier = Modifier
+ .fillMaxWidth()
+ .height(128.dp),
+ contentScale = ContentScale.Fit
+ )
+ }
+ )
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/alarm/CarelevoAlarmHost.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/alarm/CarelevoAlarmHost.kt
new file mode 100644
index 000000000000..c0300406af38
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/alarm/CarelevoAlarmHost.kt
@@ -0,0 +1,180 @@
+package app.aaps.pump.carelevo.compose.alarm
+
+import android.app.Activity
+import android.bluetooth.BluetoothAdapter
+import android.content.Context
+import android.content.Intent
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.ui.IconsProvider
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.common.CarelevoAlarmNotifier
+import app.aaps.pump.carelevo.domain.model.alarm.CarelevoAlarmInfo
+import app.aaps.pump.carelevo.domain.type.AlarmCause
+import app.aaps.pump.carelevo.domain.type.AlarmType.Companion.isCritical
+import app.aaps.pump.carelevo.ext.transformStringResources
+import app.aaps.pump.carelevo.presentation.model.AlarmEvent
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoAlarmViewModel
+
+@Composable
+internal fun CarelevoAlarmHost(
+ aapsLogger: AAPSLogger,
+ carelevoAlarmNotifier: CarelevoAlarmNotifier,
+ iconsProvider: IconsProvider,
+ snackbarHostState: SnackbarHostState
+) {
+ val context = LocalContext.current
+ val viewModel: CarelevoAlarmViewModel = hiltViewModel()
+ val notifierAlarms = carelevoAlarmNotifier.alarms.collectAsStateWithLifecycle().value
+ val alarmQueue = viewModel.alarmQueue.collectAsStateWithLifecycle().value
+ var dismissedAlarmId by remember { mutableStateOf(null) }
+ val currentAlarm = alarmQueue.firstOrNull { it.alarmId != dismissedAlarmId }
+ var pendingMessageRes by remember { mutableStateOf(null) }
+ val pendingMessage = pendingMessageRes?.let { stringResource(it) }
+
+ val requestBtLauncher = rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+ if (result.resultCode == Activity.RESULT_OK) {
+ viewModel.alarmInfo?.let {
+ aapsLogger.debug(LTag.PUMPCOMM, "bluetooth enabled for alarm=${it.alarmId}")
+ }
+ }
+ }
+
+ // Register as the active in-app alarm surface: while mounted, the plugin suppresses its global
+ // runAlarm fallback (this host presents the rich alarm screen and starts the sound itself).
+ DisposableEffect(Unit) {
+ carelevoAlarmNotifier.alarmHostActive = true
+ onDispose { carelevoAlarmNotifier.alarmHostActive = false }
+ }
+
+ LaunchedEffect(notifierAlarms) {
+ if (notifierAlarms.any { it.alarmType.isCritical() }) {
+ aapsLogger.debug(LTag.PUMPCOMM, "load alarms from notifier alarms=$notifierAlarms")
+ viewModel.loadActiveAlarms()
+ }
+ }
+
+ LaunchedEffect(viewModel) {
+ viewModel.event.collect { event ->
+ when (event) {
+ AlarmEvent.RequestBluetoothEnable -> {
+ val enableBtIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
+ requestBtLauncher.launch(enableBtIntent)
+ }
+
+ is AlarmEvent.ShowToastMessage -> {
+ pendingMessageRes = event.messageRes
+ }
+
+ else -> Unit
+ }
+ }
+ }
+
+ LaunchedEffect(pendingMessage) {
+ pendingMessage?.let { message ->
+ snackbarHostState.showSnackbar(message)
+ pendingMessageRes = null
+ }
+ }
+
+ LaunchedEffect(currentAlarm?.alarmId) {
+ if (currentAlarm != null) {
+ // Hand the presented alarm to the VM first so the alarm dialog carries its title.
+ viewModel.alarmInfo = currentAlarm
+ viewModel.triggerEvent(AlarmEvent.StartAlarm)
+ }
+ }
+
+ LaunchedEffect(alarmQueue, dismissedAlarmId) {
+ if (dismissedAlarmId != null && alarmQueue.none { it.alarmId == dismissedAlarmId }) {
+ dismissedAlarmId = null
+ }
+ }
+
+ CarelevoAlarmScreen(
+ alarm = currentAlarm?.let { buildAlarmUiModel(context, iconsProvider, it) },
+ onPrimaryClick = {
+ currentAlarm?.let {
+ dismissedAlarmId = it.alarmId
+ viewModel.triggerEvent(AlarmEvent.ClearAlarm(info = it))
+ }
+ },
+ onMuteClick = {
+ viewModel.triggerEvent(AlarmEvent.Mute)
+ },
+ onMute5MinClick = {
+ viewModel.triggerEvent(AlarmEvent.Mute5min)
+ }
+ )
+}
+
+private fun buildAlarmUiModel(
+ context: Context,
+ iconsProvider: IconsProvider,
+ alarm: CarelevoAlarmInfo
+): CarelevoAlarmUiModel {
+ val (titleRes, descRes, btnRes) = alarm.cause.transformStringResources()
+ val descArgs = buildDescArgsFor(context, alarm)
+ val desc = descRes?.let { resId ->
+ if (descArgs.isEmpty()) context.getString(resId) else context.getString(resId, *descArgs.toTypedArray())
+ } ?: ""
+
+ return CarelevoAlarmUiModel(
+ appIcon = iconsProvider.getIcon(),
+ title = context.getString(titleRes),
+ content = desc,
+ primaryButtonText = context.getString(btnRes),
+ muteButtonText = context.getString(CoreUiR.string.mute),
+ mute5minButtonText = context.getString(CoreUiR.string.mute5min)
+ )
+}
+
+private fun buildDescArgsFor(context: Context, alarm: CarelevoAlarmInfo): List = when (alarm.cause) {
+ AlarmCause.ALARM_NOTICE_LOW_INSULIN,
+ AlarmCause.ALARM_ALERT_OUT_OF_INSULIN -> {
+ listOf((alarm.value ?: 0).toString())
+ }
+
+ AlarmCause.ALARM_NOTICE_PATCH_EXPIRED -> {
+ val totalHours = alarm.value ?: 0
+ val days = totalHours / 24
+ val hours = totalHours % 24
+ listOf(days.toString(), hours.toString())
+ }
+
+ AlarmCause.ALARM_NOTICE_BG_CHECK -> {
+ val totalMinutes = alarm.value ?: 0
+ val hours = totalMinutes / 60
+ val minutes = totalMinutes % 60
+ listOf(
+ when {
+ hours > 0 && minutes > 0 ->
+ context.getString(R.string.common_label_unit_value_duration_hour_and_minute, hours, minutes)
+
+ hours > 0 ->
+ context.getString(R.string.common_label_unit_value_duration_hour, hours)
+
+ else ->
+ context.getString(R.string.common_label_unit_value_minute, minutes)
+ }
+ )
+ }
+
+ else -> emptyList()
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/alarm/CarelevoAlarmScreen.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/alarm/CarelevoAlarmScreen.kt
new file mode 100644
index 000000000000..ddd16b66ee02
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/alarm/CarelevoAlarmScreen.kt
@@ -0,0 +1,178 @@
+package app.aaps.pump.carelevo.compose.alarm
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.fromHtml
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.core.ui.compose.AapsSpacing
+import app.aaps.pump.carelevo.R
+
+internal data class CarelevoAlarmUiModel(
+ val appIcon: Int,
+ val title: String,
+ val content: String,
+ val primaryButtonText: String,
+ val muteButtonText: String,
+ val mute5minButtonText: String
+)
+
+@Composable
+internal fun CarelevoAlarmScreen(
+ alarm: CarelevoAlarmUiModel?,
+ onPrimaryClick: () -> Unit,
+ onMuteClick: () -> Unit,
+ onMute5MinClick: () -> Unit
+) {
+ if (alarm == null) return
+
+ Surface(
+ modifier = Modifier.fillMaxSize(),
+ color = Color.Transparent
+ ) {
+ Box(
+ modifier = Modifier
+ .fillMaxSize()
+ // Blocking modal scrim: consume all taps so nothing underneath is reachable
+ // while a critical alarm is presented.
+ .pointerInput(Unit) { detectTapGestures { } }
+ .background(MaterialTheme.colorScheme.scrim.copy(alpha = 0.5f)),
+ contentAlignment = Alignment.Center
+ ) {
+ Card(
+ modifier = Modifier
+ .padding(horizontal = AapsSpacing.xxLarge)
+ .fillMaxWidth(),
+ shape = RoundedCornerShape(AapsSpacing.extraLarge),
+ colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainer),
+ elevation = CardDefaults.cardElevation(defaultElevation = 8.dp)
+ ) {
+ Column(
+ modifier = Modifier.padding(AapsSpacing.xxLarge),
+ verticalArrangement = Arrangement.Center,
+ horizontalAlignment = Alignment.CenterHorizontally
+ ) {
+ Box(contentAlignment = Alignment.Center) {
+ Image(
+ painter = painterResource(id = CoreUiR.drawable.ic_error_red_48dp),
+ contentDescription = null,
+ modifier = Modifier.size(48.dp)
+ )
+ Box(
+ modifier = Modifier
+ .align(Alignment.BottomEnd)
+ .size(AapsSpacing.xxLarge)
+ .background(
+ color = MaterialTheme.colorScheme.surface,
+ shape = CircleShape
+ )
+ .padding(2.dp)
+ ) {
+ Image(
+ painter = painterResource(id = alarm.appIcon),
+ contentDescription = null,
+ modifier = Modifier.size(20.dp),
+ contentScale = ContentScale.Fit
+ )
+ }
+ }
+
+ Spacer(modifier = Modifier.height(AapsSpacing.extraLarge))
+
+ Text(
+ text = alarm.title,
+ style = MaterialTheme.typography.headlineMedium,
+ textAlign = TextAlign.Center,
+ modifier = Modifier.fillMaxWidth()
+ )
+
+ Spacer(modifier = Modifier.height(AapsSpacing.extraLarge))
+
+ if (alarm.content.isNotBlank()) {
+ Text(
+ text = AnnotatedString.fromHtml(alarm.content.replace("\n", "
")),
+ style = MaterialTheme.typography.bodyMedium,
+ textAlign = TextAlign.Center,
+ modifier = Modifier.fillMaxWidth()
+ )
+ }
+
+ Spacer(modifier = Modifier.height(AapsSpacing.xxLarge))
+
+ Button(
+ onClick = onMute5MinClick,
+ modifier = Modifier.fillMaxWidth()
+ ) {
+ Text(text = alarm.mute5minButtonText)
+ }
+
+ Spacer(modifier = Modifier.height(AapsSpacing.large))
+
+ Button(
+ onClick = onMuteClick,
+ modifier = Modifier.fillMaxWidth()
+ ) {
+ Text(text = alarm.muteButtonText)
+ }
+
+ Spacer(modifier = Modifier.height(AapsSpacing.large))
+
+ Button(
+ onClick = onPrimaryClick,
+ modifier = Modifier.fillMaxWidth()
+ ) {
+ Text(text = alarm.primaryButtonText)
+ }
+ }
+ }
+ }
+ }
+}
+
+@Preview(showBackground = true, name = "Carelevo Alarm")
+@Composable
+private fun CarelevoAlarmScreenPreview() {
+ MaterialTheme {
+ CarelevoAlarmScreen(
+ alarm = CarelevoAlarmUiModel(
+ appIcon = R.drawable.ic_carelevo_128,
+ title = "Low insulin warning",
+ content = "Insulin remaining is below threshold.
Please confirm and replace soon.",
+ primaryButtonText = "Confirm",
+ muteButtonText = "Mute",
+ mute5minButtonText = "Mute 5 min"
+ ),
+ onPrimaryClick = {},
+ onMuteClick = {},
+ onMute5MinClick = {}
+ )
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/dialog/CarelevoActionDialog.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/dialog/CarelevoActionDialog.kt
new file mode 100644
index 000000000000..862624779fe7
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/dialog/CarelevoActionDialog.kt
@@ -0,0 +1,82 @@
+package app.aaps.pump.carelevo.compose.dialog
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.fromHtml
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+
+@Composable
+internal fun CarelevoActionDialog(
+ title: String,
+ content: String,
+ onDismissRequest: () -> Unit,
+ primaryText: String,
+ onPrimaryClick: () -> Unit,
+ secondaryText: String? = null,
+ onSecondaryClick: (() -> Unit)? = null,
+ subContent: String = ""
+) {
+ AlertDialog(
+ onDismissRequest = onDismissRequest,
+ title = { Text(text = title) },
+ text = {
+ Column(
+ modifier = Modifier.fillMaxWidth(),
+ verticalArrangement = Arrangement.spacedBy(8.dp)
+ ) {
+ if (content.isNotBlank()) {
+ Text(
+ text = if (content.contains('<') || content.contains("
")) {
+ AnnotatedString.fromHtml(content.replace("\n", "
"))
+ } else {
+ AnnotatedString(content)
+ },
+ style = MaterialTheme.typography.bodyLarge
+ )
+ }
+ if (subContent.isNotBlank()) {
+ Text(
+ text = subContent,
+ style = MaterialTheme.typography.bodyMedium
+ )
+ }
+ }
+ },
+ confirmButton = {
+ TextButton(onClick = onPrimaryClick) {
+ Text(text = primaryText)
+ }
+ },
+ dismissButton = {
+ if (secondaryText != null && onSecondaryClick != null) {
+ TextButton(onClick = onSecondaryClick) {
+ Text(text = secondaryText)
+ }
+ }
+ }
+ )
+}
+
+@Preview(showBackground = true, name = "Carelevo Action Dialog")
+@Composable
+private fun CarelevoActionDialogPreview() {
+ CarelevoActionDialog(
+ title = "Deactivate patch and start new patch?",
+ content = "Current patch will be deactivated.",
+ subContent = "This dialog preview helps verify current text alignment.",
+ onDismissRequest = {},
+ primaryText = "Deactivate",
+ onPrimaryClick = {},
+ secondaryText = "Cancel",
+ onSecondaryClick = {}
+ )
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/dialog/CarelevoPumpStopDurationDialog.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/dialog/CarelevoPumpStopDurationDialog.kt
new file mode 100644
index 000000000000..17383d805b3e
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/dialog/CarelevoPumpStopDurationDialog.kt
@@ -0,0 +1,60 @@
+package app.aaps.pump.carelevo.compose.dialog
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.aaps.pump.carelevo.R
+
+@Composable
+internal fun CarelevoPumpStopDurationDialog(
+ options: List,
+ labels: List,
+ initialIndex: Int,
+ onDismissRequest: () -> Unit,
+ onConfirm: (Int) -> Unit
+) {
+ var selectedIndex by remember(initialIndex) { mutableIntStateOf(initialIndex) }
+
+ AlertDialog(
+ onDismissRequest = onDismissRequest,
+ title = { Text(text = stringResource(R.string.carelevo_pump_stop_duration_title)) },
+ text = {
+ Column {
+ labels.forEachIndexed { index, label ->
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ RadioButton(
+ selected = selectedIndex == index,
+ onClick = { selectedIndex = index }
+ )
+ Text(text = label)
+ }
+ }
+ }
+ },
+ confirmButton = {
+ TextButton(onClick = { onConfirm(options[selectedIndex]) }) {
+ Text(text = stringResource(R.string.carelevo_btn_confirm))
+ }
+ },
+ dismissButton = {
+ TextButton(onClick = onDismissRequest) {
+ Text(text = stringResource(R.string.carelevo_btn_cancel))
+ }
+ }
+ )
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowScreen.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowScreen.kt
new file mode 100644
index 000000000000..baac59a5b3eb
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowScreen.kt
@@ -0,0 +1,217 @@
+package app.aaps.pump.carelevo.compose.patchflow
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.res.stringResource
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.core.ui.compose.AapsSpacing
+import app.aaps.core.ui.compose.ToolbarConfig
+import app.aaps.core.ui.compose.pump.ProfileGateWizardStep
+import app.aaps.core.ui.compose.pump.WizardScreen
+import app.aaps.core.ui.compose.siteRotation.SiteLocationWizardStep
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.common.model.UiState
+import app.aaps.pump.carelevo.presentation.model.CarelevoConnectEvent
+import app.aaps.pump.carelevo.presentation.type.CarelevoPatchStep
+import app.aaps.pump.carelevo.presentation.type.CarelevoScreenType
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchConnectViewModel
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchConnectionFlowViewModel
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchNeedleInsertionViewModel
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchSafetyCheckViewModel
+
+@Composable
+internal fun CarelevoPatchFlowScreen(
+ screenType: CarelevoScreenType,
+ setToolbarConfig: (ToolbarConfig) -> Unit,
+ snackbarHostState: SnackbarHostState,
+ onExitFlow: () -> Unit
+) {
+ CarelevoPatchConnectionFlowScreen(
+ screenType = screenType,
+ setToolbarConfig = setToolbarConfig,
+ snackbarHostState = snackbarHostState,
+ onExitFlow = onExitFlow
+ )
+}
+
+@Composable
+private fun CarelevoPatchConnectionFlowScreen(
+ screenType: CarelevoScreenType,
+ setToolbarConfig: (ToolbarConfig) -> Unit,
+ snackbarHostState: SnackbarHostState,
+ onExitFlow: () -> Unit
+) {
+ val viewModel: CarelevoPatchConnectionFlowViewModel = hiltViewModel()
+ val connectViewModel: CarelevoPatchConnectViewModel = hiltViewModel()
+ val needleInsertionViewModel: CarelevoPatchNeedleInsertionViewModel = hiltViewModel()
+ val safetyCheckViewModel: CarelevoPatchSafetyCheckViewModel = hiltViewModel()
+ val page by viewModel.page.collectAsStateWithLifecycle()
+ val totalSteps by viewModel.totalSteps.collectAsStateWithLifecycle()
+ val currentStepIndex by viewModel.currentStepIndex.collectAsStateWithLifecycle()
+ val sharedUiState by viewModel.uiState.collectAsStateWithLifecycle()
+ val connectUiState by connectViewModel.uiState.collectAsStateWithLifecycle()
+ val needleInsertionUiState by needleInsertionViewModel.uiState.collectAsStateWithLifecycle()
+ val safetyCheckUiState by safetyCheckViewModel.uiState.collectAsStateWithLifecycle()
+ val discardFailedMessage = stringResource(R.string.carelevo_toast_msg_discard_failed)
+
+ // Every exit path MUST drop the ViewModel's one-shot init latch: the VM outlives this screen
+ // (it is scoped to the plugin's NavBackStackEntry), so without the reset a SECOND activation
+ // started from the same plugin visit would reuse the previous run's workflowSteps and page —
+ // i.e. the wizard could resume at NEEDLE_INSERTION against a brand-new, never-safety-checked
+ // patch. The latch itself stays (it is what preserves mid-flow progress across rotation).
+ val exitFlow: () -> Unit = remember(viewModel, onExitFlow) {
+ {
+ viewModel.setIsCreated(false)
+ onExitFlow()
+ }
+ }
+
+ LaunchedEffect(viewModel) {
+ if (!viewModel.isCreated) {
+ viewModel.initWorkflow(screenType)
+ viewModel.setIsCreated(true)
+ }
+ }
+
+ LaunchedEffect(page) {
+ if (page == CarelevoPatchStep.PATCH_CONNECT) {
+ connectViewModel.resetForEnterStep()
+ }
+ }
+
+ LaunchedEffect(viewModel) {
+ viewModel.event.collect { event ->
+ when (event) {
+ CarelevoConnectEvent.DiscardComplete -> exitFlow()
+
+ CarelevoConnectEvent.DiscardFailed -> {
+ snackbarHostState.showSnackbar(discardFailedMessage)
+ }
+
+ CarelevoConnectEvent.ExitFlow -> exitFlow()
+
+ else -> Unit
+ }
+ }
+ }
+
+ Box(
+ modifier = Modifier
+ .fillMaxSize()
+ ) {
+ WizardScreen(
+ currentStep = page,
+ totalSteps = totalSteps,
+ currentStepIndex = currentStepIndex,
+ canGoBack = true,
+ onBack = { viewModel.startPatchDiscardProcess() },
+ cancelDialogTitle = stringResource(R.string.carelevo_dialog_patch_discard_message_title),
+ cancelDialogText = stringResource(R.string.carelevo_dialog_patch_discard_message_desc),
+ title = patchStepTitle(page),
+ setToolbarConfig = setToolbarConfig,
+ ) { step, _ ->
+ when (step) {
+ CarelevoPatchStep.PROFILE_GATE -> {
+ ProfileGateWizardStep(host = viewModel)
+ }
+
+ CarelevoPatchStep.SELECT_INSULIN -> {
+ CarelevoSelectInsulinStep(viewModel = viewModel)
+ }
+
+ CarelevoPatchStep.PATCH_START -> {
+ CarelevoPatchFlowStep01Start(
+ viewModel = viewModel,
+ onExitFlow = exitFlow
+ )
+ }
+
+ CarelevoPatchStep.SET_AMOUNT -> {
+ CarelevoSetAmountStep(viewModel = viewModel)
+ }
+
+ CarelevoPatchStep.PATCH_CONNECT -> {
+ CarelevoPatchFlowStep02Connect(
+ viewModel = connectViewModel,
+ sharedViewModel = viewModel,
+ onExitFlow = exitFlow
+ )
+ }
+
+ CarelevoPatchStep.SAFETY_CHECK -> {
+ CarelevoPatchFlowStep03SafetyCheck(
+ viewModel = safetyCheckViewModel,
+ sharedViewModel = viewModel,
+ onExitFlow = exitFlow
+ )
+ }
+
+ CarelevoPatchStep.SITE_LOCATION -> {
+ SiteLocationWizardStep(host = viewModel)
+ }
+
+ CarelevoPatchStep.PATCH_ATTACH -> {
+ CarelevoPatchFlowStep04Attach(
+ viewModel = viewModel
+ )
+ }
+
+ CarelevoPatchStep.NEEDLE_INSERTION -> {
+ CarelevoPatchFlowStep05NeedleInsertion(
+ viewModel = needleInsertionViewModel,
+ onExitFlow = exitFlow
+ )
+ }
+ }
+ }
+
+ val activeUiState = when (page) {
+ CarelevoPatchStep.PATCH_CONNECT -> connectUiState
+ CarelevoPatchStep.NEEDLE_INSERTION -> needleInsertionUiState
+ CarelevoPatchStep.SAFETY_CHECK -> safetyCheckUiState
+ else -> sharedUiState
+ }
+
+ if (activeUiState is UiState.Loading) {
+ Box(
+ modifier = Modifier
+ .fillMaxSize()
+ .background(MaterialTheme.colorScheme.scrim.copy(alpha = 0.32f))
+ // Consume all taps: without this the scrim is decoration only and a
+ // double-tap can still reach (and re-fire) the buttons underneath while
+ // the first BLE command is in flight.
+ .pointerInput(Unit) { detectTapGestures { } },
+ contentAlignment = Alignment.Center
+ ) {
+ Column(
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(AapsSpacing.extraLarge)
+ ) {
+ CircularProgressIndicator(color = MaterialTheme.colorScheme.primary)
+ Text(
+ text = stringResource(CoreUiR.string.loading),
+ color = MaterialTheme.colorScheme.onSurface,
+ style = MaterialTheme.typography.bodyLarge
+ )
+ }
+ }
+ }
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep01Start.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep01Start.kt
new file mode 100644
index 000000000000..c9944cd89642
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep01Start.kt
@@ -0,0 +1,115 @@
+package app.aaps.pump.carelevo.compose.patchflow
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.core.ui.compose.AapsSpacing
+import app.aaps.core.ui.compose.pump.WizardButton
+import app.aaps.core.ui.compose.pump.WizardStepLayout
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.config.FillConfig
+import app.aaps.pump.carelevo.presentation.type.CarelevoPatchStep
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchConnectionFlowViewModel
+
+@Composable
+internal fun CarelevoPatchFlowStep01Start(
+ viewModel: CarelevoPatchConnectionFlowViewModel,
+ onExitFlow: () -> Unit
+) {
+ CarelevoPatchStartContent(
+ onNextClick = { viewModel.setPage(CarelevoPatchStep.SET_AMOUNT) },
+ onCancelClick = onExitFlow
+ )
+}
+
+@Composable
+private fun CarelevoPatchStartContent(
+ onNextClick: () -> Unit,
+ onCancelClick: () -> Unit
+) {
+ var guideExpanded by remember { mutableStateOf(false) }
+ WizardStepLayout(
+ primaryButton = WizardButton(
+ text = stringResource(CoreUiR.string.next),
+ onClick = onNextClick
+ ),
+ secondaryButton = WizardButton(
+ text = stringResource(CoreUiR.string.cancel),
+ onClick = onCancelClick
+ )
+ ) {
+ Text(
+ text = stringResource(R.string.carelevo_title_fill_insulin),
+ style = MaterialTheme.typography.titleMedium
+ )
+ Text(
+ text = stringResource(R.string.carelevo_notice_fill_insulin_amount, FillConfig.FILL_MIN_UNITS, FillConfig.FILL_MAX_UNITS),
+ style = MaterialTheme.typography.bodyMedium
+ )
+ CarelevoInsulinRefillGuideSection(
+ expanded = guideExpanded,
+ onExpand = { guideExpanded = true }
+ )
+ }
+}
+
+@Composable
+private fun CarelevoInsulinRefillGuideSection(
+ expanded: Boolean,
+ onExpand: () -> Unit
+) {
+ if (!expanded) {
+ Button(onClick = onExpand) {
+ Text(text = stringResource(R.string.carelevo_btn_insulin_guide))
+ }
+ return
+ }
+
+ val steps = listOf(
+ stringResource(R.string.carelevo_insulin_refill_step1),
+ stringResource(R.string.carelevo_insulin_refill_step2),
+ stringResource(R.string.carelevo_insulin_refill_step3),
+ stringResource(R.string.carelevo_insulin_refill_step4),
+ stringResource(R.string.carelevo_insulin_refill_step5),
+ stringResource(R.string.carelevo_insulin_refill_step6),
+ stringResource(R.string.carelevo_insulin_refill_step7),
+ stringResource(R.string.carelevo_insulin_refill_step8),
+ stringResource(R.string.carelevo_insulin_refill_step9),
+ stringResource(R.string.carelevo_insulin_refill_step10),
+ stringResource(R.string.carelevo_insulin_refill_step11),
+ stringResource(R.string.carelevo_insulin_refill_step12)
+ )
+ Column(verticalArrangement = Arrangement.spacedBy(AapsSpacing.large)) {
+ Text(
+ text = stringResource(R.string.carelevo_btn_insulin_guide),
+ style = MaterialTheme.typography.titleSmall
+ )
+ steps.forEach { step ->
+ Text(
+ text = step,
+ style = MaterialTheme.typography.bodyMedium
+ )
+ }
+ }
+}
+
+@Preview(showBackground = true, name = "Patch Start")
+@Composable
+private fun CarelevoPatchFlowStep01StartPreview() {
+ MaterialTheme {
+ CarelevoPatchStartContent(
+ onNextClick = {},
+ onCancelClick = {}
+ )
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep02Connect.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep02Connect.kt
new file mode 100644
index 000000000000..43e15e1a4cdf
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep02Connect.kt
@@ -0,0 +1,197 @@
+package app.aaps.pump.carelevo.compose.patchflow
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.aaps.core.ui.compose.AapsSpacing
+import app.aaps.core.ui.compose.banner.ErrorBanner
+import app.aaps.core.ui.compose.pump.WizardButton
+import app.aaps.core.ui.compose.pump.WizardStepLayout
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.compose.dialog.CarelevoActionDialog
+import app.aaps.pump.carelevo.presentation.model.CarelevoConnectPrepareEvent
+import app.aaps.pump.carelevo.presentation.type.CarelevoPatchStep
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchConnectViewModel
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchConnectionFlowViewModel
+
+@Composable
+internal fun CarelevoPatchFlowStep02Connect(
+ viewModel: CarelevoPatchConnectViewModel,
+ sharedViewModel: CarelevoPatchConnectionFlowViewModel,
+ onExitFlow: () -> Unit
+) {
+ var showDiscardDialog by remember { mutableStateOf(false) }
+ var showConnectDialog by remember { mutableStateOf(false) }
+ var errorMessage by remember { mutableStateOf(null) }
+
+ LaunchedEffect(viewModel, sharedViewModel) {
+ viewModel.event.collect { event ->
+ when (event) {
+ CarelevoConnectPrepareEvent.ShowConnectDialog -> {
+ showConnectDialog = true
+ }
+
+ CarelevoConnectPrepareEvent.ShowMessageScanFailed -> {
+ errorMessage = R.string.carelevo_toast_msg_scan_failed
+ }
+
+ CarelevoConnectPrepareEvent.ShowMessageBluetoothNotEnabled -> {
+ errorMessage = R.string.carelevo_toast_msg_bluetooth_not_enabled
+ }
+
+ CarelevoConnectPrepareEvent.ShowMessageScanIsWorking -> Unit
+
+ CarelevoConnectPrepareEvent.ShowMessageNotSetUserSettingInfo -> {
+ errorMessage = R.string.carelevo_toast_msg_profile_not_set
+ }
+
+ CarelevoConnectPrepareEvent.ShowMessageSelectedDeviceIseEmpty -> {
+ errorMessage = R.string.carelevo_toast_msg_patch_not_found
+ }
+
+ CarelevoConnectPrepareEvent.ConnectFailed -> {
+ showConnectDialog = false
+ errorMessage = R.string.carelevo_toast_msg_connect_failed
+ }
+
+ CarelevoConnectPrepareEvent.ConnectComplete -> {
+ showConnectDialog = false
+ errorMessage = null
+ sharedViewModel.setPage(CarelevoPatchStep.SAFETY_CHECK)
+ }
+
+ CarelevoConnectPrepareEvent.DiscardComplete -> {
+ showDiscardDialog = false
+ onExitFlow()
+ }
+
+ CarelevoConnectPrepareEvent.DiscardFailed -> {
+ showDiscardDialog = false
+ errorMessage = R.string.carelevo_toast_msg_discard_failed
+ }
+
+ CarelevoConnectPrepareEvent.NoAction -> Unit
+ }
+ }
+ }
+
+ if (showDiscardDialog) {
+ CarelevoActionDialog(
+ onDismissRequest = { showDiscardDialog = false },
+ title = stringResource(R.string.carelevo_dialog_patch_discard_message_title),
+ content = stringResource(R.string.carelevo_dialog_patch_discard_message_desc),
+ primaryText = stringResource(R.string.carelevo_btn_confirm),
+ onPrimaryClick = {
+ showDiscardDialog = false
+ viewModel.startPatchDiscardProcess()
+ },
+ secondaryText = stringResource(R.string.carelevo_btn_cancel),
+ onSecondaryClick = { showDiscardDialog = false }
+ )
+ }
+
+ if (showConnectDialog) {
+ CarelevoActionDialog(
+ onDismissRequest = { showConnectDialog = false },
+ title = stringResource(R.string.carelevo_dialog_patch_connect_message_title),
+ content = "CareLevo",
+ primaryText = stringResource(R.string.carelevo_btn_confirm),
+ onPrimaryClick = {
+ showConnectDialog = false
+ viewModel.startConnect(sharedViewModel.inputInsulin)
+ },
+ secondaryText = stringResource(R.string.carelevo_btn_research),
+ onSecondaryClick = {
+ showConnectDialog = false
+ viewModel.startScan()
+ }
+ )
+ }
+
+ CarelevoPatchConnectContent(
+ errorMessage = errorMessage,
+ onDiscardClick = { showDiscardDialog = true },
+ onSearchClick = {
+ errorMessage = null
+ viewModel.startScan()
+ }
+ )
+}
+
+@Composable
+private fun CarelevoPatchConnectContent(
+ errorMessage: Int?,
+ onDiscardClick: () -> Unit,
+ onSearchClick: () -> Unit
+) {
+ WizardStepLayout(
+ primaryButton = WizardButton(
+ text = stringResource(R.string.carelevo_btn_input_search_patch),
+ onClick = onSearchClick
+ ),
+ secondaryButton = WizardButton(
+ text = stringResource(R.string.carelevo_btn_patch_expiration),
+ onClick = onDiscardClick
+ )
+ ) {
+ errorMessage?.let { ErrorBanner(message = stringResource(it)) }
+ CarelevoPatchConnectStepSection(
+ stepLabel = stringResource(R.string.carelevo_patch_step_1),
+ title = stringResource(R.string.carelevo_patch_connect_step_1_title),
+ description = stringResource(R.string.carelevo_patch_connect_step_1_desc)
+ )
+ CarelevoPatchConnectStepSection(
+ stepLabel = stringResource(R.string.carelevo_patch_step_2),
+ title = stringResource(R.string.carelevo_patch_connect_step_2_title),
+ description = stringResource(R.string.carelevo_patch_connect_step_2_desc)
+ )
+ }
+}
+
+@Composable
+private fun CarelevoPatchConnectStepSection(
+ stepLabel: String,
+ title: String,
+ description: String
+) {
+ Column(verticalArrangement = Arrangement.spacedBy(AapsSpacing.medium)) {
+ Row(horizontalArrangement = Arrangement.spacedBy(AapsSpacing.small), verticalAlignment = Alignment.Bottom) {
+ Text(
+ text = stepLabel,
+ style = MaterialTheme.typography.titleMedium
+ )
+ Text(
+ text = title,
+ style = MaterialTheme.typography.titleMedium
+ )
+ }
+
+ Text(
+ text = description,
+ style = MaterialTheme.typography.bodyMedium
+ )
+ }
+}
+
+@Preview(showBackground = true, name = "Patch Connect")
+@Composable
+private fun CarelevoPatchFlowStep02ConnectPreview() {
+ MaterialTheme {
+ CarelevoPatchConnectContent(
+ errorMessage = null,
+ onDiscardClick = {},
+ onSearchClick = {}
+ )
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep03SafetyCheck.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep03SafetyCheck.kt
new file mode 100644
index 000000000000..a07676941d05
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep03SafetyCheck.kt
@@ -0,0 +1,324 @@
+package app.aaps.pump.carelevo.compose.patchflow
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.wrapContentWidth
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Info
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.aaps.core.ui.compose.AapsSpacing
+import app.aaps.core.ui.compose.banner.ErrorBanner
+import app.aaps.core.ui.compose.pump.WizardButton
+import app.aaps.core.ui.compose.pump.WizardStepLayout
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.compose.dialog.CarelevoActionDialog
+import app.aaps.pump.carelevo.presentation.model.CarelevoConnectSafetyCheckEvent
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchConnectionFlowViewModel
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchSafetyCheckViewModel
+
+@Composable
+internal fun CarelevoPatchFlowStep03SafetyCheck(
+ viewModel: CarelevoPatchSafetyCheckViewModel,
+ sharedViewModel: CarelevoPatchConnectionFlowViewModel,
+ onExitFlow: () -> Unit
+) {
+ val progress by viewModel.progress.collectAsStateWithLifecycle()
+ val remainSec by viewModel.remainSec.collectAsStateWithLifecycle()
+ var showDiscardDialog by remember { mutableStateOf(false) }
+ var errorMessage by remember { mutableStateOf(null) }
+ var safetyCheckState by remember(viewModel) {
+ mutableStateOf(
+ if (viewModel.isSafetyCheckPassed()) {
+ SafetyCheckUiState.Success
+ } else {
+ SafetyCheckUiState.Ready
+ }
+ )
+ }
+
+ LaunchedEffect(viewModel) {
+ if (!viewModel.isCreated) {
+ viewModel.setIsCreated(true)
+ }
+ if (viewModel.isSafetyCheckPassed()) {
+ viewModel.onSafetyCheckComplete()
+ }
+ }
+
+ LaunchedEffect(viewModel) {
+ viewModel.event.collect { event ->
+ when (event) {
+ CarelevoConnectSafetyCheckEvent.ShowMessageBluetoothNotEnabled -> {
+ errorMessage = R.string.carelevo_toast_msg_bluetooth_not_enabled
+ }
+
+ CarelevoConnectSafetyCheckEvent.ShowMessageCarelevoIsNotConnected -> {
+ errorMessage = R.string.carelevo_toast_msg_not_connected_waiting_retry
+ }
+
+ CarelevoConnectSafetyCheckEvent.SafetyCheckProgress -> {
+ errorMessage = null
+ safetyCheckState = SafetyCheckUiState.Progress
+ }
+
+ CarelevoConnectSafetyCheckEvent.SafetyCheckComplete -> {
+ errorMessage = null
+ safetyCheckState = SafetyCheckUiState.Success
+ }
+
+ CarelevoConnectSafetyCheckEvent.SafetyCheckFailed -> {
+ errorMessage = R.string.carelevo_toast_msg_safety_check_failed
+ safetyCheckState = SafetyCheckUiState.Ready
+ }
+
+ CarelevoConnectSafetyCheckEvent.DiscardComplete -> {
+ showDiscardDialog = false
+ onExitFlow()
+ }
+
+ CarelevoConnectSafetyCheckEvent.DiscardFailed -> {
+ showDiscardDialog = false
+ errorMessage = R.string.carelevo_toast_msg_discard_failed
+ }
+
+ CarelevoConnectSafetyCheckEvent.NoAction -> Unit
+ }
+ }
+ }
+
+ if (showDiscardDialog) {
+ CarelevoActionDialog(
+ onDismissRequest = { showDiscardDialog = false },
+ title = stringResource(R.string.carelevo_dialog_patch_discard_message_title),
+ content = stringResource(R.string.carelevo_dialog_patch_discard_message_desc),
+ primaryText = stringResource(R.string.carelevo_btn_confirm),
+ onPrimaryClick = {
+ showDiscardDialog = false
+ viewModel.startDiscardProcess()
+ },
+ secondaryText = stringResource(R.string.carelevo_btn_cancel),
+ onSecondaryClick = { showDiscardDialog = false }
+ )
+ }
+
+ val titleRes = when (safetyCheckState) {
+ SafetyCheckUiState.Ready,
+ SafetyCheckUiState.Progress -> R.string.carelevo_patch_safety_check_start_title
+
+ SafetyCheckUiState.Success -> R.string.carelevo_patch_safety_check_end_title
+ }
+ val descRes = when (safetyCheckState) {
+ SafetyCheckUiState.Ready -> R.string.carelevo_patch_safety_check_start_desc
+ SafetyCheckUiState.Progress -> R.string.carelevo_patch_safety_check_progress_desc
+ SafetyCheckUiState.Success -> R.string.carelevo_patch_safety_check_end_desc
+ }
+
+ val nextEnabled = safetyCheckState == SafetyCheckUiState.Success
+ val showSafetyCheckButton = safetyCheckState == SafetyCheckUiState.Ready
+ val showRetrySection = safetyCheckState == SafetyCheckUiState.Success
+ val showProgressDetails = safetyCheckState != SafetyCheckUiState.Ready
+ // While the ~100-210 s check is streaming, block the discard escape hatch: tapping it would
+ // enqueue a CmdDiscard behind the still-running CmdSafetyCheck — a confusing interleaving
+ // that never reflects what the user sees on screen. (The global Loading overlay is deliberately
+ // NOT used here — it would hide this step's live progress display.)
+ val discardEnabled = safetyCheckState != SafetyCheckUiState.Progress
+
+ CarelevoPatchFlowStep03SafetyCheckContent(
+ titleRes = titleRes,
+ descRes = descRes,
+ errorMessage = errorMessage,
+ progress = progress,
+ remainSec = remainSec,
+ showProgressDetails = showProgressDetails,
+ showRetrySection = showRetrySection,
+ showSafetyCheckButton = showSafetyCheckButton,
+ nextEnabled = nextEnabled,
+ discardEnabled = discardEnabled,
+ onRetryClick = {
+ errorMessage = null
+ viewModel.retryAdditionalPriming()
+ },
+ onDiscardClick = { showDiscardDialog = true },
+ onSafetyCheckClick = {
+ errorMessage = null
+ viewModel.startSafetyCheck()
+ },
+ onNextClick = { sharedViewModel.advanceFromSafetyCheck() }
+ )
+}
+
+@Composable
+private fun CarelevoPatchFlowStep03SafetyCheckContent(
+ titleRes: Int,
+ descRes: Int,
+ errorMessage: Int?,
+ progress: Int?,
+ remainSec: Long?,
+ showProgressDetails: Boolean,
+ showRetrySection: Boolean,
+ showSafetyCheckButton: Boolean,
+ nextEnabled: Boolean,
+ discardEnabled: Boolean = true,
+ onRetryClick: () -> Unit,
+ onDiscardClick: () -> Unit,
+ onSafetyCheckClick: () -> Unit,
+ onNextClick: () -> Unit
+) {
+ WizardStepLayout(
+ primaryButton = if (showSafetyCheckButton) {
+ WizardButton(
+ text = stringResource(R.string.carelevo_btn_safety_check),
+ onClick = onSafetyCheckClick
+ )
+ } else {
+ WizardButton(
+ text = stringResource(R.string.carelevo_btn_next),
+ onClick = onNextClick,
+ enabled = nextEnabled
+ )
+ },
+ secondaryButton = WizardButton(
+ text = stringResource(R.string.carelevo_btn_patch_expiration),
+ onClick = onDiscardClick,
+ enabled = discardEnabled
+ )
+ ) {
+ errorMessage?.let { ErrorBanner(message = stringResource(it)) }
+ Text(
+ text = stringResource(titleRes),
+ style = MaterialTheme.typography.titleMedium
+ )
+ Text(
+ text = stringResource(descRes),
+ style = MaterialTheme.typography.bodyMedium
+ )
+ LinearProgressIndicator(
+ progress = { if (showProgressDetails) (progress ?: 0) / 100f else 0f },
+ modifier = Modifier
+ .fillMaxWidth()
+ .height(10.dp)
+ )
+ if (showProgressDetails && (remainSec != null || progress != null)) {
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ horizontalArrangement = Arrangement.SpaceBetween
+ ) {
+ Text(
+ text = remainTimeText(remainSec),
+ style = MaterialTheme.typography.bodyMedium
+ )
+ Text(
+ text = progressText(progress),
+ style = MaterialTheme.typography.bodyMedium
+ )
+ }
+ }
+ if (showRetrySection) {
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(AapsSpacing.small)
+ ) {
+ Icon(
+ imageVector = Icons.Filled.Info,
+ contentDescription = null,
+ tint = MaterialTheme.colorScheme.primary
+ )
+ Text(
+ text = stringResource(R.string.carelevo_patch_safety_check_desc_warning),
+ style = MaterialTheme.typography.bodyMedium
+ )
+ }
+ Text(
+ text = stringResource(R.string.carelevo_patch_safety_check_retry_desc),
+ style = MaterialTheme.typography.bodyMedium
+ )
+ Button(
+ onClick = onRetryClick,
+ modifier = Modifier.wrapContentWidth()
+ ) {
+ Text(text = stringResource(R.string.carelevo_btn_retry))
+ }
+ }
+ }
+}
+
+private enum class SafetyCheckUiState {
+ Ready,
+ Progress,
+ Success
+}
+
+@Composable
+private fun remainTimeText(remainSeconds: Long?): String {
+ if (remainSeconds == null) return ""
+ val minutes = remainSeconds / 60
+ val seconds = remainSeconds % 60
+ return stringResource(R.string.common_unit_remain_min_sec, minutes, seconds)
+}
+
+@Composable
+private fun progressText(progress: Int?): String =
+ if (progress == null) "" else stringResource(R.string.carelevo_progress_of_100, progress)
+
+@Preview(showBackground = true, name = "Safety Check Ready")
+@Composable
+private fun CarelevoPatchFlowStep03SafetyCheckReadyPreview() {
+ MaterialTheme {
+ CarelevoPatchFlowStep03SafetyCheckContent(
+ titleRes = R.string.carelevo_patch_safety_check_start_title,
+ descRes = R.string.carelevo_patch_safety_check_start_desc,
+ errorMessage = null,
+ progress = 0,
+ remainSec = 180,
+ showProgressDetails = false,
+ showRetrySection = false,
+ showSafetyCheckButton = true,
+ nextEnabled = false,
+ onRetryClick = {},
+ onDiscardClick = {},
+ onSafetyCheckClick = {},
+ onNextClick = {}
+ )
+ }
+}
+
+@Preview(showBackground = true, name = "Safety Check Success")
+@Composable
+private fun CarelevoPatchFlowStep03SafetyCheckSuccessPreview() {
+ MaterialTheme {
+ CarelevoPatchFlowStep03SafetyCheckContent(
+ titleRes = R.string.carelevo_patch_safety_check_end_title,
+ descRes = R.string.carelevo_patch_safety_check_end_desc,
+ errorMessage = null,
+ progress = 100,
+ remainSec = 0,
+ showProgressDetails = true,
+ showRetrySection = true,
+ showSafetyCheckButton = false,
+ nextEnabled = true,
+ onRetryClick = {},
+ onDiscardClick = {},
+ onSafetyCheckClick = {},
+ onNextClick = {}
+ )
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep04Attach.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep04Attach.kt
new file mode 100644
index 000000000000..579e62156003
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep04Attach.kt
@@ -0,0 +1,94 @@
+package app.aaps.pump.carelevo.compose.patchflow
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.core.ui.compose.AapsSpacing
+import app.aaps.core.ui.compose.pump.WizardButton
+import app.aaps.core.ui.compose.pump.WizardStepLayout
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.presentation.type.CarelevoPatchStep
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchConnectionFlowViewModel
+
+@Composable
+internal fun CarelevoPatchFlowStep04Attach(
+ viewModel: CarelevoPatchConnectionFlowViewModel
+) {
+ CarelevoPatchFlowStep04AttachContent(
+ onReadyClick = { viewModel.setPage(CarelevoPatchStep.NEEDLE_INSERTION) }
+ )
+}
+
+@Composable
+private fun CarelevoPatchFlowStep04AttachContent(
+ onReadyClick: () -> Unit
+) {
+ WizardStepLayout(
+ primaryButton = WizardButton(
+ text = stringResource(CoreUiR.string.next),
+ onClick = onReadyClick
+ )
+ ) {
+ CarelevoPatchAttachSection(
+ stepLabel = stringResource(R.string.carelevo_patch_step_1),
+ title = stringResource(R.string.carelevo_patch_attach_step1_title),
+ description = stringResource(R.string.carelevo_patch_attach_step1_desc)
+ )
+ CarelevoPatchAttachSection(
+ stepLabel = stringResource(R.string.carelevo_patch_step_2),
+ title = stringResource(R.string.carelevo_patch_attach_step2_title),
+ description = stringResource(R.string.carelevo_patch_attach_step2_desc)
+ )
+ CarelevoPatchAttachSection(
+ stepLabel = stringResource(R.string.carelevo_patch_step_3),
+ title = stringResource(R.string.carelevo_patch_attach_step3_title),
+ description = stringResource(R.string.carelevo_patch_attach_step3_desc)
+ )
+ Text(
+ text = stringResource(R.string.carelevo_patch_attach_step4_desc),
+ style = MaterialTheme.typography.bodyLarge
+ )
+ }
+}
+
+@Composable
+private fun CarelevoPatchAttachSection(
+ stepLabel: String,
+ title: String,
+ description: String
+) {
+ Column(verticalArrangement = Arrangement.spacedBy(AapsSpacing.medium)) {
+ Row(horizontalArrangement = Arrangement.spacedBy(AapsSpacing.small), verticalAlignment = Alignment.Bottom) {
+ Text(
+ text = stepLabel,
+ style = MaterialTheme.typography.titleMedium
+ )
+ Text(
+ text = title,
+ style = MaterialTheme.typography.titleMedium
+ )
+ }
+
+ Text(
+ text = description,
+ style = MaterialTheme.typography.bodyMedium
+ )
+ }
+}
+
+@Preview(showBackground = true, name = "Patch Attach")
+@Composable
+private fun CarelevoPatchFlowStep04AttachPreview() {
+ MaterialTheme {
+ CarelevoPatchFlowStep04AttachContent(
+ onReadyClick = {}
+ )
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep05NeedleInsertion.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep05NeedleInsertion.kt
new file mode 100644
index 000000000000..9f262cf1099a
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowStep05NeedleInsertion.kt
@@ -0,0 +1,273 @@
+package app.aaps.pump.carelevo.compose.patchflow
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Warning
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.fromHtml
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.aaps.core.ui.compose.AapsSpacing
+import app.aaps.core.ui.compose.banner.ErrorBanner
+import app.aaps.core.ui.compose.pump.WizardButton
+import app.aaps.core.ui.compose.pump.WizardStepLayout
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.compose.dialog.CarelevoActionDialog
+import app.aaps.pump.carelevo.presentation.model.CarelevoConnectNeedleEvent
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchNeedleInsertionViewModel
+
+private const val MAX_NEEDLE_CHECK_COUNT = 3
+
+@Composable
+internal fun CarelevoPatchFlowStep05NeedleInsertion(
+ viewModel: CarelevoPatchNeedleInsertionViewModel,
+ onExitFlow: () -> Unit
+) {
+ val isNeedleInserted by viewModel.isNeedleInsert.collectAsStateWithLifecycle()
+ var showDiscardDialog by remember { mutableStateOf(false) }
+ var failCount by remember { mutableIntStateOf(0) }
+ var errorMessage by remember { mutableStateOf(null) }
+
+ LaunchedEffect(viewModel) {
+ if (!viewModel.isCreated) {
+ viewModel.observePatchInfo()
+ viewModel.setIsCreated(true)
+ }
+ }
+
+ LaunchedEffect(viewModel) {
+ viewModel.event.collect { event ->
+ when (event) {
+ CarelevoConnectNeedleEvent.ShowMessageBluetoothNotEnabled -> {
+ errorMessage = R.string.carelevo_toast_msg_bluetooth_not_enabled
+ }
+
+ CarelevoConnectNeedleEvent.ShowMessageCarelevoIsNotConnected -> {
+ errorMessage = R.string.carelevo_toast_msg_not_connected_waiting_retry
+ }
+
+ CarelevoConnectNeedleEvent.ShowMessageProfileNotSet -> {
+ errorMessage = R.string.carelevo_toast_msg_profile_not_set
+ }
+
+ is CarelevoConnectNeedleEvent.CheckNeedleComplete -> {
+ errorMessage = null
+ }
+
+ is CarelevoConnectNeedleEvent.CheckNeedleFailed -> {
+ failCount = event.failedCount
+ if (event.failedCount >= MAX_NEEDLE_CHECK_COUNT) {
+ onExitFlow()
+ }
+ }
+
+ CarelevoConnectNeedleEvent.CheckNeedleError -> {
+ errorMessage = R.string.carelevo_toast_msg_needle_check_failed
+ }
+
+ CarelevoConnectNeedleEvent.DiscardComplete -> {
+ showDiscardDialog = false
+ onExitFlow()
+ }
+
+ CarelevoConnectNeedleEvent.DiscardFailed -> {
+ showDiscardDialog = false
+ errorMessage = R.string.carelevo_toast_msg_discard_failed
+ }
+
+ CarelevoConnectNeedleEvent.SetBasalComplete -> {
+ onExitFlow()
+ }
+
+ CarelevoConnectNeedleEvent.SetBasalFailed -> {
+ errorMessage = R.string.carelevo_toast_msg_set_basal_failed
+ }
+
+ CarelevoConnectNeedleEvent.NoAction -> Unit
+ }
+ }
+ }
+
+ if (showDiscardDialog) {
+ CarelevoActionDialog(
+ onDismissRequest = { showDiscardDialog = false },
+ title = stringResource(R.string.carelevo_dialog_patch_discard_message_title),
+ content = stringResource(R.string.carelevo_dialog_patch_discard_message_desc),
+ primaryText = stringResource(R.string.carelevo_btn_confirm),
+ onPrimaryClick = {
+ showDiscardDialog = false
+ viewModel.startDiscardProcess()
+ },
+ secondaryText = stringResource(R.string.carelevo_btn_cancel),
+ onSecondaryClick = { showDiscardDialog = false }
+ )
+ }
+
+ CarelevoPatchFlowStep05NeedleInsertionContent(
+ isNeedleInserted = isNeedleInserted,
+ failCount = failCount,
+ errorMessage = errorMessage,
+ onCheckClick = {
+ errorMessage = null
+ viewModel.startCheckNeedle()
+ },
+ onStartDeliveryClick = {
+ errorMessage = null
+ viewModel.startSetBasal()
+ },
+ onDiscardClick = { showDiscardDialog = true }
+ )
+}
+
+@Composable
+private fun CarelevoPatchFlowStep05NeedleInsertionContent(
+ isNeedleInserted: Boolean,
+ failCount: Int,
+ errorMessage: Int?,
+ onCheckClick: () -> Unit,
+ onStartDeliveryClick: () -> Unit,
+ onDiscardClick: () -> Unit
+) {
+ val deactivateButton = WizardButton(
+ text = stringResource(R.string.carelevo_btn_patch_expiration),
+ onClick = onDiscardClick
+ )
+
+ if (isNeedleInserted) {
+ // Needle detected — guide the user to detach the applicator, then start delivery.
+ WizardStepLayout(
+ primaryButton = WizardButton(
+ text = stringResource(R.string.carelevo_dialog_connect_detached),
+ onClick = onStartDeliveryClick
+ ),
+ secondaryButton = deactivateButton
+ ) {
+ errorMessage?.let { ErrorBanner(message = stringResource(it)) }
+ Text(
+ text = stringResource(R.string.carelevo_dialog_patch_connect_needle_injected),
+ style = MaterialTheme.typography.titleMedium
+ )
+ Text(
+ text = AnnotatedString.fromHtml(
+ stringResource(R.string.carelevo_dialog_connect_detach_applicator_guide).replace("\n", "
")
+ ),
+ style = MaterialTheme.typography.bodyMedium
+ )
+ }
+ return
+ }
+
+ // Needle not detected yet — show insertion instructions and let the user run the check.
+ val isRetry = failCount > 0
+ WizardStepLayout(
+ primaryButton = WizardButton(
+ text = if (isRetry) {
+ stringResource(R.string.carelevo_btn_retry)
+ } else {
+ stringResource(R.string.carelevo_btn_needle_insert_check)
+ },
+ onClick = onCheckClick
+ ),
+ secondaryButton = deactivateButton
+ ) {
+ errorMessage?.let { ErrorBanner(message = stringResource(it)) }
+ CarelevoPatchNeedleSection(
+ stepLabel = stringResource(R.string.carelevo_patch_step_1),
+ title = stringResource(R.string.carelevo_patch_needle_insertion_step1_title),
+ description = stringResource(R.string.carelevo_patch_needle_insertion_step1_desc)
+ )
+ CarelevoPatchNeedleSection(
+ stepLabel = stringResource(R.string.carelevo_patch_step_2),
+ title = stringResource(R.string.carelevo_patch_needle_insertion_step2_title),
+ description = stringResource(R.string.carelevo_patch_needle_insertion_step2_desc)
+ )
+
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(AapsSpacing.medium)
+ ) {
+ Icon(
+ imageVector = Icons.Filled.Warning,
+ contentDescription = null,
+ tint = MaterialTheme.colorScheme.tertiary
+ )
+ Text(
+ text = stringResource(R.string.carelevo_patch_needle_insertion_desc_warning),
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.tertiary
+ )
+ }
+
+ if (isRetry) {
+ Text(
+ text = stringResource(
+ R.string.carelevo_dialog_patch_needle_retry_count,
+ (MAX_NEEDLE_CHECK_COUNT - failCount).coerceAtLeast(0)
+ ),
+ style = MaterialTheme.typography.bodyMedium
+ )
+ }
+ }
+}
+
+@Composable
+private fun CarelevoPatchNeedleSection(
+ stepLabel: String,
+ title: String,
+ description: String
+) {
+ Column(verticalArrangement = Arrangement.spacedBy(AapsSpacing.medium)) {
+ Row(horizontalArrangement = Arrangement.spacedBy(AapsSpacing.small), verticalAlignment = Alignment.Bottom) {
+ Text(text = stepLabel, style = MaterialTheme.typography.titleMedium)
+ Text(text = title, style = MaterialTheme.typography.titleMedium)
+ }
+ Text(text = description, style = MaterialTheme.typography.bodyMedium)
+ }
+}
+
+@Preview(showBackground = true, name = "Needle Insertion - not detected")
+@Composable
+private fun CarelevoPatchFlowStep05NotDetectedPreview() {
+ MaterialTheme {
+ CarelevoPatchFlowStep05NeedleInsertionContent(
+ isNeedleInserted = false,
+ failCount = 0,
+ errorMessage = null,
+ onCheckClick = {},
+ onStartDeliveryClick = {},
+ onDiscardClick = {}
+ )
+ }
+}
+
+@Preview(showBackground = true, name = "Needle Insertion - detected")
+@Composable
+private fun CarelevoPatchFlowStep05DetectedPreview() {
+ MaterialTheme {
+ CarelevoPatchFlowStep05NeedleInsertionContent(
+ isNeedleInserted = true,
+ failCount = 0,
+ errorMessage = null,
+ onCheckClick = {},
+ onStartDeliveryClick = {},
+ onDiscardClick = {}
+ )
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowSupport.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowSupport.kt
new file mode 100644
index 000000000000..b044b4db8f65
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoPatchFlowSupport.kt
@@ -0,0 +1,21 @@
+package app.aaps.pump.carelevo.compose.patchflow
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.presentation.type.CarelevoPatchStep
+
+@Composable
+internal fun patchStepTitle(step: CarelevoPatchStep): String =
+ when (step) {
+ CarelevoPatchStep.PROFILE_GATE -> stringResource(CoreUiR.string.pump_wizard_profile_gate_title)
+ CarelevoPatchStep.SELECT_INSULIN -> stringResource(CoreUiR.string.select_insulin)
+ CarelevoPatchStep.PATCH_START -> stringResource(R.string.carelevo_connect_prepare_title)
+ CarelevoPatchStep.SET_AMOUNT -> stringResource(R.string.patch_prepare_dialog_title_insulin_amount)
+ CarelevoPatchStep.PATCH_CONNECT -> stringResource(R.string.carelevo_connect_patch_title)
+ CarelevoPatchStep.SAFETY_CHECK -> stringResource(R.string.carelevo_connect_safety_check_title)
+ CarelevoPatchStep.SITE_LOCATION -> stringResource(CoreUiR.string.site_rotation)
+ CarelevoPatchStep.PATCH_ATTACH -> stringResource(R.string.carelevo_connect_patch_attach_title)
+ CarelevoPatchStep.NEEDLE_INSERTION -> stringResource(R.string.carelevo_connect_needle_check_title)
+ }
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoSelectInsulinStep.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoSelectInsulinStep.kt
new file mode 100644
index 000000000000..1755e8738831
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoSelectInsulinStep.kt
@@ -0,0 +1,46 @@
+package app.aaps.pump.carelevo.compose.patchflow
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.res.stringResource
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.core.ui.compose.insulin.SelectInsulin
+import app.aaps.core.ui.compose.pump.WizardButton
+import app.aaps.core.ui.compose.pump.WizardStepLayout
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchConnectionFlowViewModel
+
+/**
+ * Wizard step letting the user pick which insulin the pump/loop should use. Shown only when more
+ * than one insulin is configured (`showInsulinStep`). Mirrors the Medtrum/Equil insulin step and
+ * reuses the shared [SelectInsulin] picker.
+ */
+@Composable
+internal fun CarelevoSelectInsulinStep(
+ viewModel: CarelevoPatchConnectionFlowViewModel
+) {
+ val availableInsulins by viewModel.availableInsulins.collectAsStateWithLifecycle()
+ val selectedInsulin by viewModel.selectedInsulin.collectAsStateWithLifecycle()
+ val activeInsulinLabel by viewModel.activeInsulinLabel.collectAsStateWithLifecycle()
+
+ WizardStepLayout(
+ primaryButton = WizardButton(
+ text = stringResource(CoreUiR.string.next),
+ onClick = { viewModel.advanceFromInsulin() },
+ enabled = selectedInsulin != null
+ ),
+ secondaryButton = WizardButton(
+ text = stringResource(CoreUiR.string.cancel),
+ onClick = { viewModel.exitWizard() }
+ )
+ ) {
+ SelectInsulin(
+ availableInsulins = availableInsulins,
+ selectedInsulin = selectedInsulin,
+ activeInsulinLabel = activeInsulinLabel,
+ onInsulinSelect = { viewModel.selectInsulin(it) },
+ initialExpanded = true,
+ concentrationDropDownEnabled = viewModel.concentrationEnabled
+ )
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoSetAmountStep.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoSetAmountStep.kt
new file mode 100644
index 000000000000..d656f4187673
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/compose/patchflow/CarelevoSetAmountStep.kt
@@ -0,0 +1,209 @@
+package app.aaps.pump.carelevo.compose.patchflow
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.snapping.rememberSnapFlingBehavior
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import app.aaps.core.ui.R as CoreUiR
+import app.aaps.core.ui.compose.pump.WizardButton
+import app.aaps.core.ui.compose.pump.WizardStepLayout
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.config.FillConfig
+import app.aaps.pump.carelevo.presentation.viewmodel.CarelevoPatchConnectionFlowViewModel
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import kotlin.math.abs
+
+/**
+ * Wizard step for choosing the insulin fill amount. Replaces the former bottom sheet so the choice
+ * stays on the wizard rails (progress indicator, Next/Cancel). The wheel picker is non-scrolling
+ * content, so [WizardStepLayout] is used with `scrollable = false`.
+ */
+@Composable
+internal fun CarelevoSetAmountStep(
+ viewModel: CarelevoPatchConnectionFlowViewModel
+) {
+ var selectedValue by remember { mutableIntStateOf(viewModel.inputInsulin) }
+ val values = remember { (FillConfig.FILL_MIN_UNITS..FillConfig.FILL_MAX_UNITS step FillConfig.FILL_STEP_UNITS).toList() }
+
+ WizardStepLayout(
+ primaryButton = WizardButton(
+ text = stringResource(CoreUiR.string.next),
+ onClick = { viewModel.confirmAmount(selectedValue) }
+ ),
+ secondaryButton = WizardButton(
+ text = stringResource(CoreUiR.string.cancel),
+ onClick = { viewModel.exitWizard() }
+ ),
+ scrollable = false
+ ) {
+ Text(
+ text = stringResource(R.string.patch_prepare_dialog_msg_insulin_range, FillConfig.FILL_MIN_UNITS, FillConfig.FILL_MAX_UNITS),
+ style = MaterialTheme.typography.bodyMedium
+ )
+ Box(
+ modifier = Modifier
+ .fillMaxWidth()
+ .height(WheelItemHeight * WheelVisibleRows)
+ ) {
+ CarelevoWheelPicker(
+ values = values,
+ selectedValue = selectedValue,
+ onValueSelected = { selectedValue = it }
+ )
+ }
+ }
+}
+
+private val WheelItemHeight = 52.dp
+private const val WheelVisibleRows = 5
+
+@Composable
+private fun CarelevoWheelPicker(
+ values: List,
+ selectedValue: Int,
+ onValueSelected: (Int) -> Unit
+) {
+ val initialIndex = remember(values, selectedValue) {
+ values.indexOf(selectedValue).coerceAtLeast(0)
+ }
+ val listState = rememberLazyListState(
+ initialFirstVisibleItemIndex = initialIndex
+ )
+ val flingBehavior = rememberSnapFlingBehavior(lazyListState = listState)
+ val centerRowIndex = WheelVisibleRows / 2
+ val verticalContentPadding = WheelItemHeight * centerRowIndex
+ val coroutineScope = rememberCoroutineScope()
+ var centeredIndex by remember(values, selectedValue) { mutableIntStateOf(initialIndex) }
+
+ LaunchedEffect(listState, values) {
+ snapshotFlow { listState.layoutInfo.visibleItemsInfo }
+ .filter { it.isNotEmpty() }
+ .map { visibleItems ->
+ val viewportCenter = (listState.layoutInfo.viewportStartOffset + listState.layoutInfo.viewportEndOffset) / 2
+ visibleItems.minByOrNull { item ->
+ abs((item.offset + item.size / 2) - viewportCenter)
+ }?.index?.coerceIn(0, values.lastIndex) ?: centeredIndex
+ }
+ .distinctUntilChanged()
+ .collect { selectedIndex ->
+ centeredIndex = selectedIndex
+ onValueSelected(values[selectedIndex])
+ }
+ }
+
+ LaunchedEffect(selectedValue, values) {
+ val selectedIndex = values.indexOf(selectedValue)
+ if (selectedIndex >= 0 && selectedIndex != centeredIndex) {
+ centeredIndex = selectedIndex
+ listState.animateScrollToItem(selectedIndex)
+ }
+ }
+
+ Box(
+ modifier = Modifier.fillMaxWidth(),
+ contentAlignment = Alignment.Center
+ ) {
+ LazyColumn(
+ state = listState,
+ flingBehavior = flingBehavior,
+ modifier = Modifier.fillMaxWidth(),
+ contentPadding = PaddingValues(vertical = verticalContentPadding),
+ horizontalAlignment = Alignment.CenterHorizontally
+ ) {
+ itemsIndexed(values) { index, value ->
+ val isSelected = index == centeredIndex
+ WheelRow(
+ value = value,
+ isSelected = isSelected,
+ onClick = {
+ coroutineScope.launch {
+ centeredIndex = index
+ listState.animateScrollToItem(index)
+ }
+ }
+ )
+ }
+ }
+
+ WheelSelectionOverlay()
+ }
+}
+
+@Composable
+private fun WheelRow(
+ value: Int,
+ isSelected: Boolean,
+ onClick: () -> Unit
+) {
+ Box(
+ modifier = Modifier
+ .fillMaxWidth()
+ .height(WheelItemHeight)
+ .padding(horizontal = 24.dp)
+ .clip(RoundedCornerShape(14.dp))
+ .clickable(onClick = onClick)
+ .background(
+ if (isSelected) {
+ MaterialTheme.colorScheme.primary.copy(alpha = 0.10f)
+ } else {
+ Color.Transparent
+ }
+ ),
+ contentAlignment = Alignment.Center
+ ) {
+ Text(
+ text = value.toString(),
+ style = if (isSelected) {
+ MaterialTheme.typography.headlineSmall
+ } else {
+ MaterialTheme.typography.titleMedium
+ },
+ fontWeight = if (isSelected) FontWeight.Bold else FontWeight.Normal
+ )
+ }
+}
+
+@Composable
+private fun WheelSelectionOverlay() {
+ val overlayHeight = WheelItemHeight
+ Box(
+ modifier = Modifier
+ .fillMaxWidth()
+ .height(overlayHeight)
+ .padding(horizontal = 24.dp)
+ .clip(RoundedCornerShape(14.dp))
+ .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.18f))
+ ) {
+ HorizontalDivider(modifier = Modifier.align(Alignment.TopCenter))
+ HorizontalDivider(modifier = Modifier.align(Alignment.BottomCenter))
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/config/CarelevoConfig.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/config/CarelevoConfig.kt
new file mode 100644
index 000000000000..3d7ebcb57044
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/config/CarelevoConfig.kt
@@ -0,0 +1,38 @@
+package app.aaps.pump.carelevo.config
+
+class BleEnvConfig {
+ companion object {
+
+ const val BLE_CCC_DESCRIPTOR = "00002902-0000-1000-8000-00805f9b34fb"
+ const val BLE_SERVICE_UUID = "e1b40001-ffc4-4daa-a49b-1c92f99072ab"
+ const val BLE_TX_CHAR_UUID = "e1b40003-ffc4-4daa-a49b-1c92f99072ab"
+ const val BLE_RX_CHAR_UUID = "e1b40002-ffc4-4daa-a49b-1c92f99072ab"
+ }
+}
+
+/**
+ * Insulin fill limits of the patch reservoir. Single source of truth for the wizard's amount
+ * picker AND the user-facing range texts — must stay consistent with
+ * `PumpType.CAREMEDI_CARELEVO.maxReservoirReading` (300) in `core:data`.
+ */
+class FillConfig {
+ companion object {
+
+ const val FILL_MIN_UNITS = 50
+ const val FILL_MAX_UNITS = 300
+ const val FILL_STEP_UNITS = 10
+ }
+}
+
+class PrefEnvConfig {
+ companion object {
+
+ const val PATCH_INFO = "carelevo_patch_info"
+ const val BASAL_INFUSION_INFO = "carelevo_basal_infusion_info"
+ const val TEMP_BASAL_INFUSION_INFO = "carelevo_temp_basal_infusion_info"
+ const val IMME_BOLUS_INFUSION_INFO = "carelevo_imme_bolus_infusion_info"
+ const val EXTEND_BOLUS_INFUSION_INFO = "carelevo_extend_bolus_infusion_info"
+ const val USER_SETTING_INFO = "carelevo_user_setting_info"
+ const val CARELEVO_ALARM_INFO_LIST = "carelevo_alarm_info_list"
+ }
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoAlarmClearCoordinator.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoAlarmClearCoordinator.kt
new file mode 100644
index 000000000000..741512d18ce4
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoAlarmClearCoordinator.kt
@@ -0,0 +1,100 @@
+package app.aaps.pump.carelevo.coordinator
+
+import app.aaps.core.data.pump.defs.PumpType
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.pump.PumpSync
+import app.aaps.core.interfaces.queue.CommandQueue
+import app.aaps.core.interfaces.utils.DateUtil
+import app.aaps.pump.carelevo.ble.CarelevoBleTransport
+import app.aaps.pump.carelevo.command.CmdAlarmClear
+import app.aaps.pump.carelevo.command.CmdAlarmClearPatchDiscard
+import app.aaps.pump.carelevo.command.CmdPumpResume
+import app.aaps.pump.carelevo.common.CarelevoPatch
+import app.aaps.pump.carelevo.domain.model.alarm.CarelevoAlarmInfo
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import javax.inject.Inject
+import javax.inject.Singleton
+import kotlin.jvm.optionals.getOrNull
+
+/**
+ * The alarm-clear BLE operations, shared by both clear-alarm surfaces (the Android notification action in
+ * [app.aaps.pump.carelevo.common.CarelevoAlarmActionHandler] and the in-app alarm screen in
+ * [app.aaps.pump.carelevo.presentation.viewmodel.CarelevoAlarmViewModel]). The patch-facing ops go through
+ * the AAPS CommandQueue so a resting (idle-disconnected) pump is reconnected before the op runs — a direct
+ * write would silently no-op, and the callers' old `isPatchConnected()` gate would otherwise fall to the
+ * destructive force-quit path. Each caller keeps its own alarm-cause branching, alarm-queue state and UI.
+ */
+@Singleton
+class CarelevoAlarmClearCoordinator @Inject constructor(
+ private val aapsLogger: AAPSLogger,
+ private val commandQueue: CommandQueue,
+ private val carelevoPatch: CarelevoPatch,
+ private val transport: CarelevoBleTransport,
+ private val pumpSync: PumpSync,
+ private val dateUtil: DateUtil
+) {
+
+ // Serialize the queue ops across BOTH surfaces (this is a @Singleton): CommandQueue.customCommand dedups
+ // by command CLASS and returns success=false if one of the same class is already in-flight, so two
+ // concurrent clears (notification + in-app, or two different alarms) would make the second misread as a
+ // clear-failure and locally dismiss its alarm without ever clearing it on the patch. The mutex is held
+ // for the whole command round-trip, so the second op waits and then runs its own clear.
+ private val opMutex = Mutex()
+
+ /** Acknowledge + clear the alarm ON the patch. Returns true when the patch confirmed the clear. */
+ suspend fun clearAlarmOnPatch(info: CarelevoAlarmInfo): Boolean = opMutex.withLock {
+ commandQueue.customCommand(CmdAlarmClear(info.alarmId, info.alarmType, info.cause)).success
+ }
+
+ /** Tell the patch to discard itself in response to a warning alarm. Returns true on confirmation. */
+ suspend fun discardOnAlarm(info: CarelevoAlarmInfo): Boolean = opMutex.withLock {
+ commandQueue.customCommand(CmdAlarmClearPatchDiscard(info.alarmId, info.alarmType, info.cause)).success
+ }
+
+ /**
+ * Can a discard op plausibly reach the patch? Used by the patch-ABANDON paths (serious warning
+ * discard) to decide between a graceful queue discard and an immediate local force-quit. With
+ * per-op sessions there is no resting link to inspect — "reachable" means a session can be
+ * attempted at all (patch paired + Bluetooth on); a genuinely dead patch then fails the bounded
+ * session connect (~20 s) and falls to force-quit.
+ */
+ fun isPatchReachable(): Boolean =
+ carelevoPatch.getPatchInfoAddress() != null && carelevoPatch.isBluetoothEnabled()
+
+ /** Resume infusion after an auto-suspend alarm; syncs the TBR-cancel to NS on success. */
+ suspend fun resumeInfusion(): Boolean = opMutex.withLock {
+ val success = commandQueue.customCommand(CmdPumpResume()).success
+ if (success) {
+ // Only record a TBR stop if AAPS actually believes one is running — an unguarded stop
+ // would write a spurious end-marker into treatment history on a plain resume.
+ if (pumpSync.expectedPumpState().temporaryBasal != null) {
+ pumpSync.syncStopTemporaryBasalWithPumpId(
+ timestamp = dateUtil.now(),
+ endPumpId = dateUtil.now(),
+ pumpType = PumpType.CAREMEDI_CARELEVO,
+ pumpSerial = carelevoPatch.patchInfo.value?.getOrNull()?.manufactureNumber ?: ""
+ )
+ }
+ }
+ success
+ }
+
+ /**
+ * Last-resort LOCAL teardown when the patch is being abandoned (patch-discard alarm, or the patch is
+ * genuinely unreachable): clear the bond + flush local patch state. Deliberately NOT queued — it is a
+ * one-way abandon (no resting link exists to drop). [onComplete] (the caller's alarm-queue clear)
+ * runs AFTER unbond+flush — and runs even if the unbond errors — so the local alarm queue is only
+ * cleared once the patch state has actually been flushed.
+ */
+ fun forceQuitTeardown(onComplete: () -> Unit) {
+ try {
+ carelevoPatch.getPatchInfoAddress()?.let { transport.adapter.removeBond(it.uppercase()) }
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "forceQuitTeardown.unbondError", e)
+ }
+ carelevoPatch.flushPatchInformation()
+ onComplete()
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoBasalProfileUpdateCoordinator.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoBasalProfileUpdateCoordinator.kt
new file mode 100644
index 000000000000..9348e3765bb2
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoBasalProfileUpdateCoordinator.kt
@@ -0,0 +1,203 @@
+package app.aaps.pump.carelevo.coordinator
+
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.profile.Profile
+import app.aaps.core.interfaces.pump.PumpEnactResult
+import app.aaps.core.interfaces.resources.ResourceHelper
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.ble.CarelevoBleSession
+import app.aaps.pump.carelevo.common.CarelevoPatch
+import app.aaps.pump.carelevo.domain.model.ResponseResult
+import app.aaps.pump.carelevo.domain.model.infusion.CarelevoInfusionInfoDomainModel
+import app.aaps.pump.carelevo.domain.model.result.ResultSuccess
+import app.aaps.pump.carelevo.domain.usecase.CarelevoUseCaseResponse
+import app.aaps.pump.carelevo.domain.usecase.basal.CarelevoSetBasalProgramUseCase
+import io.reactivex.rxjava3.core.Flowable
+import io.reactivex.rxjava3.core.Single
+import kotlinx.coroutines.runBlocking
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
+import javax.inject.Provider
+import javax.inject.Singleton
+import kotlin.jvm.optionals.getOrNull
+
+@Singleton
+class CarelevoBasalProfileUpdateCoordinator @Inject constructor(
+ private val aapsLogger: AAPSLogger,
+ private val rh: ResourceHelper,
+ private val pumpEnactResultProvider: Provider,
+ private val carelevoPatch: CarelevoPatch,
+ private val bleSession: CarelevoBleSession,
+ private val setBasalProgramUseCase: CarelevoSetBasalProgramUseCase
+) {
+
+ private companion object {
+
+ // Fresh-session worst case: 1 s settle + ≤20 s connect handshake + ≤30 s for the three program
+ // writes — the session's own withTimeouts fire first, this is only the outer backstop.
+ private const val BASAL_PROGRAM_TIMEOUT_SEC = 60L
+ }
+
+ private var lastProfileUpdateAttemptMs: Long = 0
+
+ fun updateBasalProfile(
+ profile: Profile,
+ cancelExtendedBolus: () -> PumpEnactResult,
+ cancelTempBasal: () -> PumpEnactResult,
+ onProfileUpdated: (Profile) -> Unit
+ ): PumpEnactResult {
+ aapsLogger.debug(LTag.PUMPCOMM, "execute.start profile=$profile")
+
+ val result = pumpEnactResultProvider.get()
+ val now = System.currentTimeMillis()
+ if (now - lastProfileUpdateAttemptMs < 30_000) {
+ // Benign debounce: a repeated profile-set within 30s is skipped, not a real failure.
+ // Do not post FAILED_UPDATE_PROFILE here — dev reclassified it to URGENT, so posting it
+ // for this non-event would ring the alarm. Log only; the real failure branches below post.
+ aapsLogger.debug(LTag.PUMPCOMM, "execute.skip tooSoon=true")
+ return result
+ .success(true)
+ .enacted(false)
+ .comment(rh.gs(R.string.carelevo_profile_update_skip_comment))
+ }
+
+ val infusionInfo = carelevoPatch.infusionInfo.value?.getOrNull()
+ val shouldUseSetBasalProgram = infusionInfo?.basalInfusionInfo == null
+
+ val response = cancelExtendedBolusRx(infusionInfo, cancelExtendedBolus)
+ .timeout(20, TimeUnit.SECONDS)
+ .retryCancelWithLog("cancelExtendedBolus")
+ .flatMap {
+ if (!it.success) throw IllegalStateException("cancelExtendedBolus failed")
+ cancelTempBasalRx(infusionInfo, cancelTempBasal)
+ .timeout(20, TimeUnit.SECONDS)
+ .retryCancelWithLog("cancelTempBasal")
+ }
+ .flatMap {
+ if (!it.success) throw IllegalStateException("cancelTempBasal failed")
+ // The program opens a fresh session (connect ≤20 s + three writes ≤30 s); its own internal
+ // timeouts fire first, this outer one is only a safety net.
+ executeBasalProgram(profile, shouldUseSetBasalProgram).timeout(BASAL_PROGRAM_TIMEOUT_SEC, TimeUnit.SECONDS)
+ }
+ .onErrorReturn { ResponseResult.Error(it) }
+ .blockingGet()
+
+ // PROFILE_SET_OK / FAILED_UPDATE_PROFILE are now posted centrally by the CommandQueue from the
+ // returned success/enacted (success && enacted → PROFILE_SET_OK; !success → FAILED_UPDATE_PROFILE),
+ // unified across all pumps — do not post them here.
+ return when (response) {
+ is ResponseResult.Success -> {
+ aapsLogger.debug(LTag.PUMPCOMM, "execute.success")
+ onProfileUpdated(profile)
+ lastProfileUpdateAttemptMs = System.currentTimeMillis()
+ result.success(true).enacted(true)
+ }
+
+ is ResponseResult.Error -> {
+ aapsLogger.error(LTag.PUMPCOMM, "execute.error error=${response.e}", response.e)
+ lastProfileUpdateAttemptMs = System.currentTimeMillis()
+ result.success(false).enacted(false)
+ }
+
+ is ResponseResult.Failure -> {
+ aapsLogger.error(LTag.PUMPCOMM, "execute.failure unknownResponse=$response")
+ lastProfileUpdateAttemptMs = System.currentTimeMillis()
+ result.success(false).enacted(false)
+ }
+ }
+ }
+
+ private fun Single.retryCancelWithLog(
+ tag: String,
+ maxRetry: Int = 3,
+ delayMs: Long = 300L
+ ): Single {
+ return retryWhen { errors ->
+ errors
+ .zipWith(Flowable.range(1, maxRetry)) { error, retryCount ->
+ if (retryCount < maxRetry) {
+ aapsLogger.warn(LTag.PUMPCOMM, "$tag.retry attempt=$retryCount/$maxRetry reason=${error.message}")
+ retryCount
+ } else {
+ aapsLogger.error(LTag.PUMPCOMM, "$tag.retry.exhausted max=$maxRetry reason=${error.message}")
+ throw error
+ }
+ }
+ .flatMap { Flowable.timer(delayMs, TimeUnit.MILLISECONDS) }
+ }
+ }
+
+ private fun executeBasalProgram(
+ profile: Profile,
+ shouldUseSetBasalProgram: Boolean
+ ): Single> {
+ aapsLogger.debug(LTag.PUMPCOMM, "executeBasalProgram mode=${if (shouldUseSetBasalProgram) "SET" else "UPDATE"}")
+ return Single.fromCallable { executeBasalProgramInternal(profile, isUpdate = !shouldUseSetBasalProgram) }
+ }
+
+ /**
+ * Basal (re)program core (**delivery-critical**). Same 3-write single-session plan as the activation
+ * set-basal in `CarelevoActivationExecutor.runSetBasal`, with [isUpdate] selecting the change opcode
+ * (0x21) instead of the set opcode (0x13). The V2 update's persist is byte-identical to set's, so both
+ * modes reuse [CarelevoSetBasalProgramUseCase]'s `buildBasalProgramPlan` + `persistBasalProgram`
+ * (mode=1 + basal infusion-info).
+ */
+ private fun executeBasalProgramInternal(profile: Profile, isUpdate: Boolean): ResponseResult = runCatching {
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: throw IllegalStateException("no patch address")
+ val plan = setBasalProgramUseCase.buildBasalProgramPlan(profile)
+ val programmed = runBlocking { bleSession.runBasalProgram(address, plan.programs, isUpdate) }
+ if (!programmed) throw IllegalStateException("basal program write failed")
+ val persisted = setBasalProgramUseCase.persistBasalProgram(plan.segments)
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.basalProfile isUpdate=$isUpdate programmed=true persisted=$persisted")
+ if (!persisted) throw IllegalStateException("basal program persist failed")
+ ResultSuccess
+ }.fold(
+ onSuccess = { ResponseResult.Success(it) },
+ onFailure = {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.basalProfile FAILED isUpdate=$isUpdate", it)
+ ResponseResult.Error(it)
+ }
+ )
+
+ private fun cancelExtendedBolusRx(
+ infusionInfo: CarelevoInfusionInfoDomainModel?,
+ cancelExtendedBolus: () -> PumpEnactResult
+ ): Single {
+ aapsLogger.debug(LTag.PUMPCOMM, "cancelExtendedBolus.start hasExtended=${infusionInfo?.extendBolusInfusionInfo != null}")
+ return if (infusionInfo?.extendBolusInfusionInfo != null) {
+ Single.fromCallable { cancelExtendedBolus() }
+ .flatMap { cancelResult ->
+ if (cancelResult.success) {
+ Single.just(cancelResult)
+ } else {
+ Single.error(IllegalStateException("cancelExtendedBolus returned success=false"))
+ }
+ }
+ .doOnError { aapsLogger.error(LTag.PUMPCOMM, "cancelExtendedBolus.error", it) }
+ } else {
+ Single.just(pumpEnactResultProvider.get().success(true).enacted(false))
+ }
+ }
+
+ private fun cancelTempBasalRx(
+ infusionInfo: CarelevoInfusionInfoDomainModel?,
+ cancelTempBasal: () -> PumpEnactResult
+ ): Single {
+ aapsLogger.debug(LTag.PUMPCOMM, "cancelTempBasal.start hasTempBasal=${infusionInfo?.tempBasalInfusionInfo != null}")
+ return if (infusionInfo?.tempBasalInfusionInfo != null) {
+ Single.fromCallable { cancelTempBasal() }
+ .flatMap { cancelResult ->
+ if (cancelResult.success) {
+ Single.just(cancelResult)
+ } else {
+ Single.error(IllegalStateException("cancelTempBasal returned success=false"))
+ }
+ }
+ .doOnError { aapsLogger.error(LTag.PUMPCOMM, "cancelTempBasal.error", it) }
+ } else {
+ Single.just(pumpEnactResultProvider.get().success(true).enacted(false))
+ }
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoBolusCoordinator.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoBolusCoordinator.kt
new file mode 100644
index 000000000000..e7ab0f5170b1
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoBolusCoordinator.kt
@@ -0,0 +1,570 @@
+package app.aaps.pump.carelevo.coordinator
+
+import android.os.SystemClock
+import app.aaps.core.data.model.BS
+import app.aaps.core.data.pump.defs.PumpType
+import app.aaps.core.data.time.T
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.pump.BolusProgressData
+import app.aaps.core.interfaces.pump.DetailedBolusInfo
+import app.aaps.core.interfaces.pump.PumpEnactResult
+import app.aaps.core.interfaces.pump.PumpInsulin
+import app.aaps.core.interfaces.pump.PumpRate
+import app.aaps.core.interfaces.pump.PumpSync
+import app.aaps.core.interfaces.resources.ResourceHelper
+import app.aaps.core.interfaces.rx.AapsSchedulers
+import app.aaps.core.interfaces.utils.DateUtil
+import app.aaps.core.interfaces.utils.Round
+import app.aaps.pump.carelevo.R
+import app.aaps.pump.carelevo.ble.CarelevoBleSession
+import app.aaps.pump.carelevo.ble.commands.BolusCancelCommand
+import app.aaps.pump.carelevo.ble.commands.ExtendBolusCancelCommand
+import app.aaps.pump.carelevo.ble.commands.ExtendBolusCommand
+import app.aaps.pump.carelevo.ble.commands.ImmediateBolusCommand
+import app.aaps.pump.carelevo.common.CarelevoPatch
+import app.aaps.pump.carelevo.coordinator.CarelevoBolusCoordinator.Companion.CANCEL_WAIT_TIMEOUT_MS
+import app.aaps.pump.carelevo.coordinator.CarelevoBolusCoordinator.Companion.NEW_STACK_CANCEL_MAX_RETRY
+import app.aaps.pump.carelevo.domain.model.ResponseResult
+import app.aaps.pump.carelevo.domain.usecase.bolus.CarelevoCancelExtendBolusInfusionUseCase
+import app.aaps.pump.carelevo.domain.usecase.bolus.CarelevoCancelImmeBolusInfusionUseCase
+import app.aaps.pump.carelevo.domain.usecase.bolus.CarelevoFinishImmeBolusInfusionUseCase
+import app.aaps.pump.carelevo.domain.usecase.bolus.CarelevoStartExtendBolusInfusionUseCase
+import app.aaps.pump.carelevo.domain.usecase.bolus.CarelevoStartImmeBolusInfusionUseCase
+import app.aaps.pump.carelevo.domain.usecase.bolus.model.StartImmeBolusInfusionResponseModel
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.kotlin.plusAssign
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.runBlocking
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+import javax.inject.Inject
+import javax.inject.Provider
+import javax.inject.Singleton
+import kotlin.jvm.optionals.getOrNull
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+@Singleton
+class CarelevoBolusCoordinator @Inject constructor(
+ private val aapsLogger: AAPSLogger,
+ private val rh: ResourceHelper,
+ private val dateUtil: DateUtil,
+ private val bolusProgressData: BolusProgressData,
+ private val pumpSync: PumpSync,
+ private val aapsSchedulers: AapsSchedulers,
+ private val pumpEnactResultProvider: Provider,
+ private val carelevoPatch: CarelevoPatch,
+ private val bleSession: CarelevoBleSession,
+ private val startImmeBolusInfusionUseCase: CarelevoStartImmeBolusInfusionUseCase,
+ private val finishImmeBolusInfusionUseCase: CarelevoFinishImmeBolusInfusionUseCase,
+ private val cancelImmeBolusInfusionUseCase: CarelevoCancelImmeBolusInfusionUseCase,
+ private val startExtendBolusInfusionUseCase: CarelevoStartExtendBolusInfusionUseCase,
+ private val cancelExtendBolusInfusionUseCase: CarelevoCancelExtendBolusInfusionUseCase
+) {
+
+ companion object {
+
+ private const val STOP_BOLUS_TIME_OUT = 15_000L
+ private const val PROGRESS_POLL_MS = 100L
+ private const val RESULT_SUCCESS = 0
+
+ // The out-of-band cancel opens a fresh GATT per attempt, so cap retries low — a single bounded
+ // connect+write settles a reachable patch; more attempts only lengthen the two-GATT-collision
+ // window against an unreachable one (which can't be stopped anyway).
+ private const val NEW_STACK_CANCEL_MAX_RETRY = 1
+
+ // Backstop only: the guard normally releases the moment the cancel session finishes (via
+ // immeBolusCancelInFlight), not on this timer. Sized to comfortably exceed a bounded cancel span so the
+ // deadline never fires mid-attempt; it just prevents an unexpected hang from blocking the worker forever.
+ private const val CANCEL_WAIT_TIMEOUT_MS = 60_000L
+ }
+
+ @Volatile private var isImmeBolusStop = false
+
+ // True for the WHOLE out-of-band cancel span (across retries) — the delivery worker's guard blocks
+ // while this is set so it can't re-dial the primary link while the cancel's GATT is open (two-GATT status-133).
+ @Volatile private var immeBolusCancelInFlight = false
+
+ // Written on the queue worker (handleBolusSuccess), read from the out-of-band cancel thread
+ // (calculateMaxRetry in cancelImmediateBolusInternal) — needs the same visibility guarantee
+ // as its two sibling flags above.
+ @Volatile private var bolusExpectMs: Long = 0
+ private val _lastBolusTime = MutableStateFlow(null)
+ val lastBolusTime: StateFlow = _lastBolusTime
+
+ private val _lastBolusAmount = MutableStateFlow(null)
+ val lastBolusAmount: StateFlow = _lastBolusAmount
+
+ fun deliverTreatment(
+ detailedBolusInfo: DetailedBolusInfo,
+ serialNumber: String,
+ onLastDataUpdated: () -> Unit,
+ pluginDisposable: CompositeDisposable
+ ): PumpEnactResult {
+ aapsLogger.debug(LTag.PUMPCOMM, "deliverTreatment.start bolusType=${detailedBolusInfo.bolusType}")
+ require(detailedBolusInfo.carbs == 0.0) { detailedBolusInfo.toString() }
+ require(detailedBolusInfo.insulin > 0) { detailedBolusInfo.toString() }
+
+ val result = pumpEnactResultProvider.get()
+ if (!carelevoPatch.isBluetoothEnabled()) {
+ return result
+ }
+
+ val infusionInfo = carelevoPatch.infusionInfo.value?.getOrNull()
+ aapsLogger.warn(
+ LTag.PUMPCOMM,
+ "deliverTreatment.gate type=${detailedBolusInfo.bolusType}, " +
+ "immeInfo=${infusionInfo?.immeBolusInfusionInfo}"
+ )
+ if (infusionInfo?.immeBolusInfusionInfo != null) {
+ aapsLogger.warn(LTag.PUMPCOMM, "deliverTreatment.reject reason=immeBolusInProgress")
+ result.success = false
+ result.enacted = false
+ result.bolusDelivered = 0.0
+ result.comment("Another bolus is in progress")
+ return result
+ }
+
+ isImmeBolusStop = false
+ val actionId = (carelevoPatch.patchInfo.value?.getOrNull()?.bolusActionSeq ?: 0) + 1
+ val normalizedActionId = if (actionId <= 0) 1 else ((actionId - 1) % 255) + 1
+
+ return deliverTreatmentInternal(detailedBolusInfo, normalizedActionId, result, serialNumber, onLastDataUpdated, pluginDisposable)
+ }
+
+ fun cancelImmediateBolus(
+ serialNumber: String,
+ onLastDataUpdated: () -> Unit
+ ) = cancelImmediateBolusInternal(serialNumber, onLastDataUpdated)
+
+ fun setExtendedBolus(
+ insulin: Double,
+ durationInMinutes: Int,
+ serialNumber: String
+ ): PumpEnactResult {
+ // Same fail-fast guard style as deliverTreatment: durationInMinutes==0 would otherwise
+ // produce speed=Infinity, silently mangled into wire bytes.
+ require(insulin > 0.0) { "extended bolus insulin must be > 0, got $insulin" }
+ require(durationInMinutes > 0) { "extended bolus duration must be > 0 min, got $durationInMinutes" }
+ val result = pumpEnactResultProvider.get()
+ if (!carelevoPatch.isBluetoothEnabled()) return result
+ return setExtendedBolusInternal(insulin, durationInMinutes, serialNumber)
+ }
+
+ fun cancelExtendedBolus(
+ serialNumber: String,
+ onLastDataUpdated: () -> Unit
+ ): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ if (!carelevoPatch.isBluetoothEnabled()) return result
+ return cancelExtendedBolusInternal(serialNumber, onLastDataUpdated)
+ }
+
+ /**
+ * Set-extended-bolus core (**delivery-critical**). Discrete `ExtendBolusCommand` (0x25→0x85) on the
+ * session — **`immediateDose` is always 0.0** (pure extended; a non-zero value injects an unintended
+ * upfront dose). On `resultCode==0` reuse the use case's `mode=5` persist → then
+ * `pumpSync.syncExtendedBolusWithPumpId`.
+ */
+ private fun setExtendedBolusInternal(
+ insulin: Double,
+ durationInMinutes: Int,
+ serialNumber: String
+ ): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ val hour = durationInMinutes / 60
+ val min = durationInMinutes % 60
+ val speed = insulin / (durationInMinutes.toDouble() / 60)
+ return try {
+ val response = runBlocking { bleSession.runSingle(address, ExtendBolusCommand(immediateDose = 0.0, extendedSpeed = speed, hour = hour, min = min)) }
+ val success = response.resultCode == RESULT_SUCCESS
+ // Once the pump ACKs, the extended bolus IS running — pumpSync must record it even if the
+ // local persist fails (otherwise IOB silently diverges from what the patch delivers).
+ val persisted = success && startExtendBolusInfusionUseCase.persistExtendBolusStarted(volume = insulin, speed = speed, minutes = durationInMinutes)
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.setExtendedBolus insulin=$insulin result=${response.resultCode} persisted=$persisted")
+ if (success && !persisted) aapsLogger.error(LTag.PUMPCOMM, "newBle.setExtendedBolus persist failed — pump enacted, recording in pumpSync anyway")
+ if (success) {
+ runBlocking {
+ pumpSync.syncExtendedBolusWithPumpId(
+ timestamp = dateUtil.now(),
+ rate = PumpRate(insulin),
+ duration = T.mins(durationInMinutes.toLong()).msecs(),
+ isEmulatingTB = false,
+ pumpId = dateUtil.now(),
+ pumpType = PumpType.CAREMEDI_CARELEVO,
+ pumpSerial = serialNumber
+ )
+ }
+ result.success = true
+ result.enacted = true
+ result
+ } else {
+ result.success = false
+ result.enacted = false
+ result
+ }
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.setExtendedBolus FAILED", e)
+ result.success = false
+ result.enacted = false
+ result
+ }
+ }
+
+ /**
+ * Cancel-extended-bolus core. Discrete `ExtendBolusCancelCommand` (0x29→0x89, response carries
+ * `infusedAmount`) on the session → delete + recompute-mode persist →
+ * `pumpSync.syncStopExtendedBolusWithPumpId`. `infusedAmount` is logged only (not reconciled into the DB).
+ */
+ private fun cancelExtendedBolusInternal(
+ serialNumber: String,
+ onLastDataUpdated: () -> Unit
+ ): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking { bleSession.runSingle(address, ExtendBolusCancelCommand()) }
+ val success = response.resultCode == RESULT_SUCCESS
+ // Same pump-is-authoritative rule as the start path: on ACK the extended bolus IS stopped
+ // on the patch, so the stop must reach pumpSync even if the local persist fails.
+ val persisted = success && cancelExtendBolusInfusionUseCase.persistExtendBolusCancelled()
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.cancelExtendedBolus result=${response.resultCode} infused=${response.infusedAmount} persisted=$persisted")
+ if (success && !persisted) aapsLogger.error(LTag.PUMPCOMM, "newBle.cancelExtendedBolus persist failed — pump stopped, recording stop in pumpSync anyway")
+ if (success) {
+ onLastDataUpdated()
+ runBlocking {
+ pumpSync.syncStopExtendedBolusWithPumpId(
+ timestamp = dateUtil.now(),
+ endPumpId = dateUtil.now(),
+ pumpType = PumpType.CAREMEDI_CARELEVO,
+ pumpSerial = serialNumber
+ )
+ }
+ result.success = true
+ result.enacted = true
+ result.isTempCancel = true
+ result
+ } else {
+ result.success = false
+ result.enacted = false
+ result
+ }
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.cancelExtendedBolus FAILED", e)
+ result.success = false
+ result.enacted = false
+ result
+ }
+ }
+
+ /**
+ * Immediate-bolus core (**delivery-critical**, Option A). Discrete `ImmediateBolusCommand` (0x24→0x84,
+ * `actionId` echoed as a stricter correlation guard) on the session; on `resultCode==0` persist
+ * the start (`mode=3`) then run the synthetic progress loop ([handleBolusSuccess]) with a synthesized
+ * success response — the pump sends no progress/completion frames, so the loop needs no BLE and runs
+ * after the start session has already closed.
+ */
+ private fun deliverTreatmentInternal(
+ detailedBolusInfo: DetailedBolusInfo,
+ actionId: Int,
+ result: PumpEnactResult,
+ serialNumber: String,
+ onLastDataUpdated: () -> Unit,
+ pluginDisposable: CompositeDisposable
+ ): PumpEnactResult {
+ val address = carelevoPatch.getPatchInfoAddress()
+ if (address == null) {
+ result.success = false
+ result.enacted = false
+ result.bolusDelivered = 0.0
+ return result.comment("no patch address")
+ }
+ return try {
+ val response = runBlocking { bleSession.runSingle(address, ImmediateBolusCommand(actionId, detailedBolusInfo.insulin)) }
+ if (response.resultCode != RESULT_SUCCESS) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.deliverTreatment start failed result=${response.resultCode}")
+ result.success = false
+ result.enacted = false
+ result.bolusDelivered = 0.0
+ return result.comment(rh.gs(R.string.alarm_feat_msg_check_patch_connect))
+ }
+ // The pump ACKed (resultCode==0) — insulin IS being delivered from this point on. The
+ // local persist is bookkeeping only: if it fails we MUST still run the delivery loop and
+ // record the bolus in pumpSync, otherwise a delivered dose would vanish from IOB and the
+ // loop could stack insulin on top of it. Persist failure is logged as a secondary fault.
+ if (!startImmeBolusInfusionUseCase.persistImmeBolusStarted(actionId, detailedBolusInfo.insulin, response.expectedCompletionSeconds)) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.deliverTreatment persist failed — continuing, pump is delivering (bookkeeping will recover on next status read)")
+ }
+ aapsLogger.info(LTag.PUMPCOMM, "ble.deliverTreatment start insulin=${detailedBolusInfo.insulin} expectSec=${response.expectedCompletionSeconds}")
+ // Start session has closed; run the synthetic progress loop with NO link (Option A) via
+ // handleBolusSuccess with a synthesized success response.
+ handleBolusSuccess(
+ ResponseResult.Success(StartImmeBolusInfusionResponseModel(expectSec = response.expectedCompletionSeconds)),
+ detailedBolusInfo,
+ result,
+ serialNumber,
+ onLastDataUpdated,
+ pluginDisposable
+ )
+ awaitImmeBolusCancelIfStopped()
+ result
+ } catch (e: Exception) {
+ handleBolusError(e, result)
+ result
+ }
+ }
+
+ /**
+ * Option A concurrency guard: if the user stopped the bolus, keep the queue worker blocked here until the
+ * OUT-OF-BAND cancel session has confirmed ([isImmeBolusStop]) — otherwise the freed worker could re-dial
+ * the primary link while the cancel's session is still open (two GATTs → status-133). Bounded
+ * by [CANCEL_WAIT_TIMEOUT_MS] so an unreachable-pump cancel can't hang the worker; a reachable patch
+ * settles in ~1-2 s.
+ */
+ private fun awaitImmeBolusCancelIfStopped() {
+ if (!bolusProgressData.isStopPressed || isImmeBolusStop) return
+ val deadline = System.currentTimeMillis() + CANCEL_WAIT_TIMEOUT_MS
+ // Block until the out-of-band cancel session has fully finished (its GATT closed) before freeing the
+ // worker. Exit on: confirmed cancel (isImmeBolusStop); OR the cancel ran and finished without confirming
+ // (engaged then cleared → gave up, so no GATT is open → safe); OR the backstop deadline.
+ var engaged = false
+ while (System.currentTimeMillis() < deadline) {
+ if (isImmeBolusStop) break
+ if (immeBolusCancelInFlight) engaged = true else if (engaged) break
+ SystemClock.sleep(PROGRESS_POLL_MS)
+ }
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.deliverTreatment stop settled isImmeBolusStop=$isImmeBolusStop inFlight=$immeBolusCancelInFlight")
+ }
+
+ /**
+ * Immediate-bolus cancel core (Option A). Stop arrives OUT-OF-BAND (off the queue worker, via
+ * `cancelAllBoluses`) while the delivery loop runs with no link, so this opens a FRESH cancel session —
+ * the session mutex serializes it against any in-flight session (the start session has already closed).
+ * Discrete `BolusCancelCommand` (0x2C→0x8C); on success record the pump-reported partial
+ * `infusedAmount` ([PumpSync]) + delete/recompute persist + set [isImmeBolusStop] (which breaks the
+ * delivery loop). Retries ONLY a timed-out attempt up to a small [NEW_STACK_CANCEL_MAX_RETRY] — each
+ * attempt is a full fresh connect, so more retries only lengthen the two-GATT window.
+ *
+ * HARDWARE ASSUMPTION (load-bearing for the retry): re-sending `BolusCancelCommand` after a
+ * timed-out attempt whose original write DID reach the pump must be a harmless no-op on an
+ * already-cancelled/finished bolus (non-SUCCESS result, no side effect). This is not verifiable
+ * in software — revalidate if the firmware protocol ever changes.
+ * [immeBolusCancelInFlight] spans the whole call so the delivery worker's guard blocks until the
+ * cancel's GATT is closed.
+ */
+ private fun cancelImmediateBolusInternal(serialNumber: String, onLastDataUpdated: () -> Unit) {
+ immeBolusCancelInFlight = true
+ try {
+ val address = carelevoPatch.getPatchInfoAddress()
+ if (address == null) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.cancelImmediateBolus no patch address")
+ return
+ }
+ val maxRetry = min(calculateMaxRetry(totalAllowedMs = bolusExpectMs).coerceAtLeast(0), NEW_STACK_CANCEL_MAX_RETRY)
+ var attempt = 0
+ while (attempt <= maxRetry && !isImmeBolusStop) {
+ try {
+ val response = runBlocking { bleSession.runSingle(address, BolusCancelCommand()) }
+ if (response.resultCode == RESULT_SUCCESS) {
+ onLastDataUpdated()
+ val infusedAmount = response.infusedAmount
+ bolusProgressData.updateProgress(
+ bolusProgressData.state.value?.percent ?: 100,
+ rh.gs(app.aaps.core.interfaces.R.string.bolus_delivered_successfully, infusedAmount.toFloat()),
+ PumpInsulin(infusedAmount)
+ )
+ val persisted = cancelImmeBolusInfusionUseCase.persistImmeBolusCancelled()
+ if (!persisted) aapsLogger.error(LTag.PUMPCOMM, "newBle.cancelImmediateBolus persist failed — stale local bolus record until next status read")
+ runBlocking {
+ pumpSync.syncBolusWithPumpId(
+ dateUtil.now(),
+ PumpInsulin(infusedAmount),
+ BS.Type.NORMAL,
+ dateUtil.now(),
+ PumpType.CAREMEDI_CARELEVO,
+ serialNumber
+ )
+ }
+ isImmeBolusStop = true
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.cancelImmediateBolus infused=$infusedAmount")
+ return
+ }
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.cancelImmediateBolus failed result=${response.resultCode}")
+ return
+ } catch (_: TimeoutCancellationException) {
+ // Only a timeout is worth another fresh-connect attempt.
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.cancelImmediateBolus timeout attempt=$attempt")
+ attempt++
+ } catch (e: Exception) {
+ // Any other failure (connect refused, BLE error): give up — do not retry.
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.cancelImmediateBolus error=$e")
+ return
+ }
+ }
+ if (!isImmeBolusStop) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.cancelImmediateBolus exhausted maxRetry=$maxRetry")
+ }
+ } finally {
+ immeBolusCancelInFlight = false
+ }
+ }
+
+ private fun handleBolusSuccess(
+ response: ResponseResult<*>,
+ detailedInfo: DetailedBolusInfo,
+ result: PumpEnactResult,
+ serialNumber: String,
+ onLastDataUpdated: () -> Unit,
+ pluginDisposable: CompositeDisposable
+ ) {
+ if (response !is ResponseResult.Success) {
+ val message = when (response) {
+ is ResponseResult.Failure -> response.message
+ is ResponseResult.Error -> response.e.message ?: response.e.toString()
+ }
+ aapsLogger.error(LTag.PUMPCOMM, "deliverTreatment.nonSuccess response=$response")
+ result.success = false
+ result.enacted = false
+ result.bolusDelivered = 0.0
+ result.comment(message)
+ return
+ }
+
+ val data = response.data as StartImmeBolusInfusionResponseModel
+
+ val now = System.currentTimeMillis()
+ onLastDataUpdated()
+ _lastBolusTime.value = now
+ _lastBolusAmount.value = PumpInsulin(detailedInfo.insulin)
+
+ val stepUnit = 0.05
+ val totalInsulin = detailedInfo.insulin
+ val totalSteps = (Round.ceilTo(totalInsulin, stepUnit) / stepUnit).roundToInt().coerceAtLeast(1)
+
+ bolusExpectMs = data.expectSec * 1000L
+ val delayMs = bolusExpectMs / totalSteps
+
+ var completed = false
+ for (step in 0..totalSteps) {
+ // Cancellation-cooperative: break promptly when the user presses stop.
+ // isStopPressed is the core flag flipped the instant the user taps stop
+ // (CommandQueue.cancelAllBoluses), while isImmeBolusStop is only set later once the
+ // pump confirms the cancel. Poll both so the progress loop stops advancing immediately
+ // instead of only after the pump round-trip.
+ if (isImmeBolusStop || bolusProgressData.isStopPressed) break
+
+ if (step == totalSteps) {
+ bolusProgressData.updateProgress(
+ 100,
+ rh.gs(
+ app.aaps.core.interfaces.R.string.bolus_delivered_successfully,
+ detailedInfo.insulin.toFloat()
+ ),
+ PumpInsulin(detailedInfo.insulin)
+ )
+ runBlocking {
+ pumpSync.syncBolusWithPumpId(
+ detailedInfo.timestamp,
+ PumpInsulin(detailedInfo.insulin),
+ detailedInfo.bolusType,
+ dateUtil.now(),
+ PumpType.CAREMEDI_CARELEVO,
+ serialNumber
+ )
+ }
+ handleFinishImmeBolus(onLastDataUpdated, pluginDisposable)
+ completed = true
+ } else {
+ // Sleep the per-step delay in short slices so a mid-step stop is honored within
+ // PROGRESS_POLL_MS rather than after the full delayMs (SystemClock.sleep is blocking
+ // and does not observe coroutine cancellation).
+ var slept = 0L
+ while (slept < delayMs && !isImmeBolusStop && !bolusProgressData.isStopPressed) {
+ val chunk = min(PROGRESS_POLL_MS, delayMs - slept)
+ SystemClock.sleep(chunk)
+ slept += chunk
+ }
+ if (isImmeBolusStop || bolusProgressData.isStopPressed) break
+ val delivering = min(step * stepUnit, detailedInfo.insulin)
+ val percent = if (totalInsulin <= 0.0) 0 else ((delivering / totalInsulin) * 100).toInt()
+ bolusProgressData.updateProgress(
+ percent,
+ rh.gs(app.aaps.core.interfaces.R.string.bolus_delivering, delivering),
+ PumpInsulin(delivering)
+ )
+ }
+ }
+
+ if (completed) {
+ result.success = true
+ result.enacted = true
+ result.bolusDelivered = detailedInfo.insulin
+ } else {
+ // User stopped mid-bolus (loop broke before the finish step). The actual partial amount is
+ // recorded separately by the cancel path via syncBolusWithPumpId(infusedAmount), so don't
+ // report the full requested dose as delivered. Matches VirtualPumpPlugin's stop contract.
+ result.success = false
+ result.enacted = false
+ result.bolusDelivered = 0.0
+ result.comment(rh.gs(app.aaps.core.ui.R.string.stop))
+ }
+ }
+
+ private fun handleBolusError(e: Throwable, result: PumpEnactResult) {
+ aapsLogger.error(LTag.PUMPCOMM, "deliverTreatment.error error=$e")
+ result.success = false
+ result.enacted = false
+ result.bolusDelivered = 0.0
+ if (e is TimeoutException) {
+ result.comment(rh.gs(R.string.alarm_feat_msg_check_patch_connect))
+ }
+ }
+
+ private fun handleFinishImmeBolus(
+ onLastDataUpdated: () -> Unit,
+ pluginDisposable: CompositeDisposable
+ ) {
+ pluginDisposable += finishImmeBolusInfusionUseCase.execute()
+ .observeOn(aapsSchedulers.main)
+ .subscribeOn(aapsSchedulers.io)
+ .timeout(3000L, TimeUnit.MILLISECONDS)
+ .subscribe(
+ { response ->
+ when (response) {
+ is ResponseResult.Success -> {
+ onLastDataUpdated()
+ aapsLogger.debug(LTag.PUMPCOMM, "finishImmeBolus.success")
+ }
+
+ is ResponseResult.Error -> {
+ aapsLogger.error(LTag.PUMPCOMM, "finishImmeBolus.responseError error=${response.e}")
+ }
+
+ else -> {
+ aapsLogger.error(LTag.PUMPCOMM, "finishImmeBolus.failure")
+ }
+ }
+ },
+ { e ->
+ aapsLogger.error(LTag.PUMPCOMM, "finishImmeBolus.subscribeError error=$e")
+ }
+ )
+ }
+
+ private fun calculateMaxRetry(
+ totalAllowedMs: Long,
+ timeoutMs: Long = STOP_BOLUS_TIME_OUT
+ ): Int {
+ aapsLogger.debug(LTag.PUMPCOMM, "stopBolus.calculateMaxRetry totalAllowedMs=$totalAllowedMs timeoutMs=$timeoutMs")
+ if (timeoutMs == 0L) {
+ return 3
+ }
+ return ((totalAllowedMs + timeoutMs - 1) / timeoutMs).toInt() - 1
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoConnectionCoordinator.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoConnectionCoordinator.kt
new file mode 100644
index 000000000000..2492281d614b
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoConnectionCoordinator.kt
@@ -0,0 +1,57 @@
+package app.aaps.pump.carelevo.coordinator
+
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.pump.carelevo.ble.CarelevoBleSession
+import app.aaps.pump.carelevo.common.CarelevoPatch
+import javax.inject.Inject
+import javax.inject.Singleton
+import kotlin.jvm.optionals.getOrNull
+
+/**
+ * The CommandQueue's connection border. Once a patch is activated the queue owns a real held link on
+ * [CarelevoBleSession]: [connect] opens it (one attempt; the queue re-polls [isConnected]), ops reuse it,
+ * and [disconnect] closes it after the queue drains — the Dash/Medtrum shape. Pre-activation [isConnected]
+ * is forced true so the queue never dials a missing/unactivated device. [isInitialized] stays
+ * activation-based. See `_docs/CARELEVO_QUEUE_OWNED_LINK.md`.
+ */
+@Singleton
+class CarelevoConnectionCoordinator @Inject constructor(
+ private val aapsLogger: AAPSLogger,
+ private val carelevoPatch: CarelevoPatch,
+ private val bleSession: CarelevoBleSession
+) {
+
+ fun isInitialized(): Boolean {
+ // Activation-based, NOT connection-based (matches Omnipod Dash / Medtrum): true once the
+ // patch is paired and its operational status has been read at least once. Must stay true with
+ // no link up, otherwise the loop's applyTBRRequest / applySMBRequest gate aborts with "pump
+ // not initialized" during the normal resting state.
+ val patchInfo = carelevoPatch.patchInfo.value?.getOrNull() ?: return false
+ return patchInfo.mode != null ||
+ patchInfo.runningMinutes != null ||
+ patchInfo.pumpState != null
+ }
+
+ /**
+ * Pre-activation → always true so the queue never dials a missing/unactivated device (the Medtrum
+ * fallback). Post-activation → the real held-link state, so the QueueWorker's connect-before-execute
+ * loop drives [connect]/[disconnect] against a link it actually owns.
+ */
+ fun isConnected(): Boolean = if (!isInitialized()) true else bleSession.connected.value
+
+ fun isConnecting(): Boolean = bleSession.isConnecting.value
+
+ /** Fire one connect attempt against the stored patch MAC; the queue re-polls [isConnected]. */
+ fun connect(reason: String) {
+ val address = carelevoPatch.getPatchInfoAddress() ?: run {
+ aapsLogger.debug(LTag.PUMPCOMM, "connect: no patch address, reason=$reason")
+ return
+ }
+ bleSession.requestConnect(address, reason)
+ }
+
+ fun disconnect(reason: String) = bleSession.requestDisconnect(reason)
+
+ fun stopConnecting() = bleSession.requestDisconnect("stopConnecting")
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoSettingsCoordinator.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoSettingsCoordinator.kt
new file mode 100644
index 000000000000..f915af14112b
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoSettingsCoordinator.kt
@@ -0,0 +1,50 @@
+package app.aaps.pump.carelevo.coordinator
+
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.rx.AapsSchedulers
+import app.aaps.pump.carelevo.domain.model.ResponseResult
+import app.aaps.pump.carelevo.domain.usecase.userSetting.CarelevoDeleteUserSettingInfoUseCase
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.kotlin.plusAssign
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * The preference-driven patch settings (max bolus, reminders, buzzer) are routed through the AAPS
+ * CommandQueue as custom commands ([app.aaps.pump.carelevo.command.CarelevoActivationExecutor]); this
+ * coordinator now only owns the shutdown-time settings clear.
+ */
+@Singleton
+class CarelevoSettingsCoordinator @Inject constructor(
+ private val aapsLogger: AAPSLogger,
+ private val aapsSchedulers: AapsSchedulers,
+ private val deleteUserSettingInfoUseCase: CarelevoDeleteUserSettingInfoUseCase
+) {
+
+ // Best-effort DIRECT write, intentionally NOT queued: it runs from the plugin's onStop() during
+ // shutdown, where reconnecting via the queue is unreliable and would block teardown. Reminder
+ // settings on the patch are non-critical, so a missed clear on stop is acceptable.
+ fun clearUserSettings(pluginDisposable: CompositeDisposable) {
+ pluginDisposable += deleteUserSettingInfoUseCase.execute()
+ .observeOn(aapsSchedulers.io)
+ .subscribeOn(aapsSchedulers.io)
+ .timeout(3000L, TimeUnit.MILLISECONDS)
+ .subscribe { response ->
+ when (response) {
+ is ResponseResult.Success -> {
+ aapsLogger.debug(LTag.PUMPCOMM, "deleteUserSettingInfo.success")
+ }
+
+ is ResponseResult.Error -> {
+ aapsLogger.debug(LTag.PUMPCOMM, "deleteUserSettingInfo.responseError error=${response.e}")
+ }
+
+ else -> {
+ aapsLogger.debug(LTag.PUMPCOMM, "deleteUserSettingInfo.failure")
+ }
+ }
+ }
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoTempBasalCoordinator.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoTempBasalCoordinator.kt
new file mode 100644
index 000000000000..f5c011098cf6
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/coordinator/CarelevoTempBasalCoordinator.kt
@@ -0,0 +1,221 @@
+package app.aaps.pump.carelevo.coordinator
+
+import app.aaps.core.data.pump.defs.PumpType
+import app.aaps.core.data.time.T
+import app.aaps.core.interfaces.logging.AAPSLogger
+import app.aaps.core.interfaces.logging.LTag
+import app.aaps.core.interfaces.pump.PumpEnactResult
+import app.aaps.core.interfaces.pump.PumpRate
+import app.aaps.core.interfaces.pump.PumpSync
+import app.aaps.core.interfaces.utils.DateUtil
+import app.aaps.pump.carelevo.ble.CarelevoBleSession
+import app.aaps.pump.carelevo.ble.commands.TempBasalCancelCommand
+import app.aaps.pump.carelevo.ble.commands.TempBasalCommand
+import app.aaps.pump.carelevo.common.CarelevoPatch
+import app.aaps.pump.carelevo.domain.usecase.basal.CarelevoCancelTempBasalInfusionUseCase
+import app.aaps.pump.carelevo.domain.usecase.basal.CarelevoStartTempBasalInfusionUseCase
+import app.aaps.pump.carelevo.domain.usecase.basal.model.StartTempBasalInfusionRequestModel
+import kotlinx.coroutines.runBlocking
+import javax.inject.Inject
+import javax.inject.Provider
+import javax.inject.Singleton
+
+@Singleton
+class CarelevoTempBasalCoordinator @Inject constructor(
+ private val aapsLogger: AAPSLogger,
+ private val dateUtil: DateUtil,
+ private val pumpSync: PumpSync,
+ private val pumpEnactResultProvider: Provider,
+ private val carelevoPatch: CarelevoPatch,
+ private val bleSession: CarelevoBleSession,
+ private val startTempBasalInfusionUseCase: CarelevoStartTempBasalInfusionUseCase,
+ private val cancelTempBasalInfusionUseCase: CarelevoCancelTempBasalInfusionUseCase
+) {
+
+ private companion object {
+
+ private const val RESULT_SUCCESS = 0
+ }
+
+ /**
+ * Set an absolute temp basal (**delivery-critical**). Discrete `TempBasalCommand.byUnit` (0x23→0x83)
+ * on the session → on `resultCode==0` reuse the use case's `mode=2` persist → then
+ * `pumpSync.syncTemporaryBasalWithPumpId`.
+ */
+ fun setTempBasalAbsolute(
+ absoluteRate: Double,
+ durationInMinutes: Int,
+ tbrType: PumpSync.TemporaryBasalType,
+ serialNumber: String,
+ onLastDataUpdated: () -> Unit
+ ): PumpEnactResult {
+ aapsLogger.info(
+ LTag.PUMPCOMM,
+ "setTempBasalAbsolute.start absoluteRate=${absoluteRate.toFloat()} durationInMinutes=${durationInMinutes.toLong()}"
+ )
+ // Fail-fast guards (same style as deliverTreatment): a zero/negative duration or rate would
+ // otherwise be silently mangled into wire bytes.
+ require(absoluteRate >= 0.0) { "TBR absolute rate must be >= 0, got $absoluteRate" }
+ require(durationInMinutes > 0) { "TBR duration must be > 0 min, got $durationInMinutes" }
+ val result = pumpEnactResultProvider.get()
+ if (!carelevoPatch.isBluetoothEnabled()) {
+ aapsLogger.info(LTag.PUMPCOMM, "setTempBasalAbsolute.skip reason=bluetoothDisabled")
+ return result
+ }
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ val hour = durationInMinutes / 60
+ val min = durationInMinutes % 60
+ return try {
+ val response = runBlocking { bleSession.runSingle(address, TempBasalCommand.byUnit(absoluteRate, hour, min)) }
+ val success = response.resultCode == RESULT_SUCCESS
+ // Pump-is-authoritative: once the patch ACKs, the TBR IS running — it must reach pumpSync
+ // even if the local persist fails, or basal IOB modeling silently diverges from reality
+ // for the whole TBR duration.
+ val persisted = success && startTempBasalInfusionUseCase.persistTempBasalStarted(
+ StartTempBasalInfusionRequestModel(isUnit = true, speed = absoluteRate, minutes = durationInMinutes)
+ )
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.setTempBasalAbsolute rate=$absoluteRate result=${response.resultCode} persisted=$persisted")
+ if (success && !persisted) aapsLogger.error(LTag.PUMPCOMM, "newBle.setTempBasalAbsolute persist failed — pump enacted, recording in pumpSync anyway")
+ if (success) {
+ onLastDataUpdated()
+ runBlocking {
+ pumpSync.syncTemporaryBasalWithPumpId(
+ timestamp = dateUtil.now(),
+ rate = PumpRate(absoluteRate),
+ duration = T.mins(durationInMinutes.toLong()).msecs(),
+ isAbsolute = true,
+ type = tbrType,
+ pumpId = dateUtil.now(),
+ pumpType = PumpType.CAREMEDI_CARELEVO,
+ pumpSerial = serialNumber
+ )
+ }
+ result.success(true).enacted(true)
+ .duration(durationInMinutes)
+ .absolute(absoluteRate)
+ .isPercent(false)
+ .isTempCancel(false)
+ } else {
+ result.success(false).enacted(false).comment("Internal error")
+ }
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.setTempBasalAbsolute FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Set a percent temp basal. Discrete `TempBasalCommand.byPercent` (5-byte, value=`percent/100`) on
+ * the session → `mode=2` persist → `pumpSync`.
+ */
+ fun setTempBasalPercent(
+ percent: Int,
+ durationInMinutes: Int,
+ tbrType: PumpSync.TemporaryBasalType,
+ serialNumber: String,
+ onLastDataUpdated: () -> Unit
+ ): PumpEnactResult {
+ require(percent >= 0) { "TBR percent must be >= 0, got $percent" }
+ require(durationInMinutes > 0) { "TBR duration must be > 0 min, got $durationInMinutes" }
+ val result = pumpEnactResultProvider.get()
+ aapsLogger.debug(LTag.PUMPCOMM, "setTempBasalPercent.start percent=$percent durationInMinutes=$durationInMinutes")
+ if (!carelevoPatch.isBluetoothEnabled()) {
+ aapsLogger.debug(LTag.PUMPCOMM, "setTempBasalPercent.skip reason=bluetoothDisabled")
+ return result
+ }
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ val hour = durationInMinutes / 60
+ val min = durationInMinutes % 60
+ return try {
+ val response = runBlocking { bleSession.runSingle(address, TempBasalCommand.byPercent(percent, hour, min)) }
+ val success = response.resultCode == RESULT_SUCCESS
+ // Pump-is-authoritative — see setTempBasalAbsolute.
+ val persisted = success && startTempBasalInfusionUseCase.persistTempBasalStarted(
+ StartTempBasalInfusionRequestModel(isUnit = false, percent = percent, minutes = durationInMinutes)
+ )
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.setTempBasalPercent percent=$percent result=${response.resultCode} persisted=$persisted")
+ if (success && !persisted) aapsLogger.error(LTag.PUMPCOMM, "newBle.setTempBasalPercent persist failed — pump enacted, recording in pumpSync anyway")
+ if (success) {
+ onLastDataUpdated()
+ runBlocking {
+ pumpSync.syncTemporaryBasalWithPumpId(
+ timestamp = dateUtil.now(),
+ rate = PumpRate(percent.toDouble()),
+ duration = T.mins(durationInMinutes.toLong()).msecs(),
+ isAbsolute = false,
+ type = tbrType,
+ pumpId = dateUtil.now(),
+ pumpType = PumpType.CAREMEDI_CARELEVO,
+ pumpSerial = serialNumber
+ )
+ }
+ result.success = true
+ result.enacted = true
+ result.duration = durationInMinutes
+ result.percent = percent
+ result.isPercent = true
+ result.isTempCancel = false
+ result
+ } else {
+ result.success(false).enacted(false).comment("Internal error")
+ }
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.setTempBasalPercent FAILED", e)
+ result.success(false).enacted(false).comment(e.message ?: "error")
+ }
+ }
+
+ /**
+ * Cancel a running temp basal. Discrete `TempBasalCancelCommand` (0x2D→0x8D) on the session →
+ * delete + recompute-mode persist → `pumpSync.syncStop…`. The session's own settle provides the
+ * inter-op spacing.
+ */
+ fun cancelTempBasal(
+ serialNumber: String,
+ onLastDataUpdated: () -> Unit
+ ): PumpEnactResult {
+ val result = pumpEnactResultProvider.get()
+ aapsLogger.debug(LTag.PUMPCOMM, "cancelTempBasal.start")
+ if (!carelevoPatch.isBluetoothEnabled()) {
+ aapsLogger.debug(LTag.PUMPCOMM, "cancelTempBasal.skip reason=bluetoothDisabled")
+ return result
+ }
+ val address = carelevoPatch.getPatchInfoAddress()
+ ?: return result.success(false).enacted(false).comment("no patch address")
+ return try {
+ val response = runBlocking { bleSession.runSingle(address, TempBasalCancelCommand()) }
+ val success = response.resultCode == RESULT_SUCCESS
+ // Pump-is-authoritative — on ACK the TBR IS stopped on the patch; the stop must reach
+ // pumpSync even if the local persist fails.
+ val persisted = success && cancelTempBasalInfusionUseCase.persistTempBasalCancelled()
+ aapsLogger.info(LTag.PUMPCOMM, "newBle.cancelTempBasal result=${response.resultCode} persisted=$persisted")
+ if (success && !persisted) aapsLogger.error(LTag.PUMPCOMM, "newBle.cancelTempBasal persist failed — pump stopped, recording stop in pumpSync anyway")
+ if (success) {
+ onLastDataUpdated()
+ runBlocking {
+ pumpSync.syncStopTemporaryBasalWithPumpId(
+ timestamp = dateUtil.now(),
+ endPumpId = dateUtil.now(),
+ pumpType = PumpType.CAREMEDI_CARELEVO,
+ pumpSerial = serialNumber
+ )
+ }
+ result.success = true
+ result.enacted = true
+ result.isTempCancel = true
+ result
+ } else {
+ result.success = false
+ result.enacted = false
+ result
+ }
+ } catch (e: Exception) {
+ aapsLogger.error(LTag.PUMPCOMM, "newBle.cancelTempBasal FAILED", e)
+ result.success = false
+ result.enacted = false
+ result
+ }
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/common/CarelevoGsonHelper.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/common/CarelevoGsonHelper.kt
new file mode 100644
index 000000000000..b902f391fa4e
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/common/CarelevoGsonHelper.kt
@@ -0,0 +1,22 @@
+package app.aaps.pump.carelevo.data.common
+
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+
+object CarelevoGsonHelper {
+
+ private var defaultGson: Gson? = null
+
+ init {
+ defaultGson = GsonBuilder()
+ .serializeSpecialFloatingPointValues()
+ .create()
+ }
+
+ fun sharedGson(): Gson {
+ if (defaultGson == null) {
+ throw RuntimeException("Not configure gson")
+ }
+ return defaultGson!!
+ }
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoAlarmInfoDao.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoAlarmInfoDao.kt
new file mode 100644
index 000000000000..715caa5a2a30
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoAlarmInfoDao.kt
@@ -0,0 +1,21 @@
+package app.aaps.pump.carelevo.data.dao
+
+import app.aaps.pump.carelevo.data.model.entities.CarelevoAlarmInfoEntity
+import io.reactivex.rxjava3.core.Completable
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+import java.util.Optional
+
+interface CarelevoAlarmInfoDao {
+
+ fun getAlarms(): Observable>>
+
+ /** One-shot read of ALL stored alarms. Everything stored is active — acknowledging removes. */
+ fun getAlarmsOnce(): Single>>
+ fun setAlarms(list: List): Completable
+ fun clearAlarms(): Completable
+ fun upsertAlarm(entity: CarelevoAlarmInfoEntity): Completable
+
+ /** Remove one alarm from the store (= acknowledge; there is no acknowledged-alarm history). */
+ fun removeAlarm(alarmId: String): Completable
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoAlarmInfoDaoImpl.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoAlarmInfoDaoImpl.kt
new file mode 100644
index 000000000000..0a7338805ced
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoAlarmInfoDaoImpl.kt
@@ -0,0 +1,106 @@
+package app.aaps.pump.carelevo.data.dao
+
+import app.aaps.core.interfaces.sharedPreferences.SP
+import app.aaps.pump.carelevo.config.PrefEnvConfig
+import app.aaps.pump.carelevo.data.common.CarelevoGsonHelper
+import app.aaps.pump.carelevo.data.model.entities.CarelevoAlarmInfoEntity
+import io.reactivex.rxjava3.core.Completable
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.subjects.BehaviorSubject
+import jakarta.inject.Inject
+import java.util.Optional
+
+class CarelevoAlarmInfoDaoImpl @Inject constructor(
+ private val prefManager: SP
+) : CarelevoAlarmInfoDao {
+
+ private val _alarms: BehaviorSubject>> = BehaviorSubject.create()
+
+ override fun getAlarms(): Observable>> {
+ // Cold-load through the SAME unfiltered loader every other method uses. The original
+ // vendor code filtered this one path to `it.acknowledged` — which is never true, because
+ // acknowledging DELETES the entity (see removeAlarm) — so every persisted active alarm
+ // (occlusion, out of insulin, …) silently vanished from the stream on process restart.
+ if (_alarms.value == null) {
+ runCatching { ensureLoaded() }
+ .onFailure { e ->
+ e.printStackTrace()
+ _alarms.onNext(Optional.ofNullable(null))
+ }
+ }
+ return _alarms
+ }
+
+ override fun getAlarmsOnce(): Single>> {
+ // Everything in the store is an active (unacknowledged) alarm by construction — an
+ // acknowledged alarm is removed, not flagged.
+ return Single.fromCallable { Optional.of(ensureLoaded()) }
+ }
+
+ override fun setAlarms(list: List): Completable {
+ return Completable.fromAction {
+ saveList(list)
+ _alarms.onNext(Optional.of(list))
+ }
+ }
+
+ override fun clearAlarms(): Completable = Completable.fromAction {
+ prefManager.remove(PrefEnvConfig.CARELEVO_ALARM_INFO_LIST)
+ _alarms.onNext(Optional.ofNullable(null))
+ }
+
+ override fun upsertAlarm(entity: CarelevoAlarmInfoEntity): Completable {
+ return Completable.fromAction {
+ val current = ensureLoaded()
+
+ val idx = current.indexOfFirst {
+ it.alarmType == entity.alarmType &&
+ it.cause == entity.cause &&
+ !it.acknowledged
+ }
+
+ val next = if (idx >= 0) {
+ current.toMutableList().apply {
+ val existing = this[idx]
+ this[idx] = existing.copy(
+ updatedAt = entity.updatedAt,
+ occurrenceCount = existing.occurrenceCount + 1
+ )
+ }
+ } else {
+ current + entity.copy(occurrenceCount = 1)
+ }
+
+ saveList(next)
+ _alarms.onNext(Optional.of(next))
+ }
+ }
+
+ override fun removeAlarm(alarmId: String): Completable {
+ return Completable.fromAction {
+ val current = ensureLoaded()
+ val next = current.filterNot { it.alarmId == alarmId }
+
+ saveList(next)
+ _alarms.onNext(Optional.of(next))
+ }
+ }
+
+ private fun ensureLoaded(): List {
+ val cached = _alarms.value?.orElse(null)
+ if (cached != null) return cached
+
+ val json = prefManager.getString(PrefEnvConfig.CARELEVO_ALARM_INFO_LIST, "")
+ val list = if (json.isBlank()) emptyList() else CarelevoGsonHelper.sharedGson()
+ .fromJson(json, Array::class.java)
+ .toList()
+ _alarms.onNext(Optional.of(list))
+ return list
+ }
+
+ private fun saveList(list: List) {
+ val json = CarelevoGsonHelper.sharedGson().toJson(list)
+ prefManager.putString(PrefEnvConfig.CARELEVO_ALARM_INFO_LIST, json)
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoInfusionInfoDao.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoInfusionInfoDao.kt
new file mode 100644
index 000000000000..95e6e564e3d0
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoInfusionInfoDao.kt
@@ -0,0 +1,26 @@
+package app.aaps.pump.carelevo.data.dao
+
+import app.aaps.pump.carelevo.data.model.entities.CarelevoBasalInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoExtendBolusInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoImmeBolusInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoTempBasalInfusionInfoEntity
+import io.reactivex.rxjava3.core.Observable
+import java.util.Optional
+
+interface CarelevoInfusionInfoDao {
+
+ fun getInfusionInfo(): Observable>
+ fun getInfusionInfoBySync(): CarelevoInfusionInfoEntity?
+
+ fun updateBasalInfusionInfo(info: CarelevoBasalInfusionInfoEntity): Boolean
+ fun updateTempBasalInfusionInfo(info: CarelevoTempBasalInfusionInfoEntity): Boolean
+ fun updateImmeBolusInfusionInfo(info: CarelevoImmeBolusInfusionInfoEntity): Boolean
+ fun updateExtendBolusInfusionInfo(info: CarelevoExtendBolusInfusionInfoEntity): Boolean
+
+ fun deleteBasalInfusionInfo(): Boolean
+ fun deleteTempBasalInfusionInfo(): Boolean
+ fun deleteImmeBolusInfusionInfo(): Boolean
+ fun deleteExtendBolusInfusionInfo(): Boolean
+ fun deleteInfusionInfo(): Boolean
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoInfusionInfoDaoImpl.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoInfusionInfoDaoImpl.kt
new file mode 100644
index 000000000000..2d913a95b847
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoInfusionInfoDaoImpl.kt
@@ -0,0 +1,141 @@
+package app.aaps.pump.carelevo.data.dao
+
+import app.aaps.core.interfaces.sharedPreferences.SP
+import app.aaps.pump.carelevo.config.PrefEnvConfig
+import app.aaps.pump.carelevo.data.common.CarelevoGsonHelper
+import app.aaps.pump.carelevo.data.model.entities.CarelevoBasalInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoExtendBolusInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoImmeBolusInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoTempBasalInfusionInfoEntity
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.subjects.BehaviorSubject
+import java.util.Optional
+import javax.inject.Inject
+import kotlin.jvm.optionals.getOrNull
+
+/**
+ * SharedPreferences-backed store of the four per-mode infusion records (basal / temp-basal /
+ * immediate bolus / extended bolus), each persisted as Gson under its own key and mirrored into
+ * one aggregate [CarelevoInfusionInfoEntity] on the [_infusionInfo] BehaviorSubject.
+ */
+class CarelevoInfusionInfoDaoImpl @Inject constructor(
+ private val prefManager: SP,
+) : CarelevoInfusionInfoDao {
+
+ private val _infusionInfo: BehaviorSubject> = BehaviorSubject.create()
+
+ /** Load one per-mode record from its preference key; null when absent or unparseable. */
+ private inline fun loadEntity(key: String): T? = runCatching {
+ val json = prefManager.getString(key, "")
+ if (json == "") throw NullPointerException("$key is empty")
+ CarelevoGsonHelper.sharedGson().fromJson(json, T::class.java)
+ }.fold(
+ onSuccess = { it },
+ onFailure = {
+ it.printStackTrace()
+ null
+ }
+ )
+
+ /** Seed [_infusionInfo] from prefs if this is the first read of the process. */
+ private fun ensureLoaded() {
+ if (_infusionInfo.value != null) return
+ val infusionInfo = CarelevoInfusionInfoEntity(
+ basalInfusionInfo = loadEntity(PrefEnvConfig.BASAL_INFUSION_INFO),
+ tempBasalInfusionInfo = loadEntity(PrefEnvConfig.TEMP_BASAL_INFUSION_INFO),
+ immeBolusInfusionInfo = loadEntity(PrefEnvConfig.IMME_BOLUS_INFUSION_INFO),
+ extendBolusInfusionInfo = loadEntity(PrefEnvConfig.EXTEND_BOLUS_INFUSION_INFO)
+ ).takeUnless { it.basalInfusionInfo == null && it.tempBasalInfusionInfo == null && it.immeBolusInfusionInfo == null && it.extendBolusInfusionInfo == null }
+ _infusionInfo.onNext(Optional.ofNullable(infusionInfo))
+ }
+
+ override fun getInfusionInfo(): Observable> {
+ ensureLoaded()
+ return _infusionInfo
+ }
+
+ override fun getInfusionInfoBySync(): CarelevoInfusionInfoEntity? {
+ ensureLoaded()
+ return _infusionInfo.value?.getOrNull()
+ }
+
+ /**
+ * Persist one per-mode record and fold it into the aggregate subject. [mutate] applies the new
+ * record to the current aggregate (creating one if none exists yet).
+ */
+ private fun updateField(key: String, info: Any, mutate: (CarelevoInfusionInfoEntity) -> CarelevoInfusionInfoEntity): Boolean = runCatching {
+ prefManager.putString(key, CarelevoGsonHelper.sharedGson().toJson(info))
+ }.fold(
+ onSuccess = {
+ val current = _infusionInfo.value?.getOrNull() ?: CarelevoInfusionInfoEntity()
+ _infusionInfo.onNext(Optional.of(mutate(current)))
+ true
+ },
+ onFailure = {
+ it.printStackTrace()
+ false
+ }
+ )
+
+ override fun updateBasalInfusionInfo(info: CarelevoBasalInfusionInfoEntity): Boolean =
+ updateField(PrefEnvConfig.BASAL_INFUSION_INFO, info) { it.copy(basalInfusionInfo = info) }
+
+ override fun updateTempBasalInfusionInfo(info: CarelevoTempBasalInfusionInfoEntity): Boolean =
+ updateField(PrefEnvConfig.TEMP_BASAL_INFUSION_INFO, info) { it.copy(tempBasalInfusionInfo = info) }
+
+ override fun updateImmeBolusInfusionInfo(info: CarelevoImmeBolusInfusionInfoEntity): Boolean =
+ updateField(PrefEnvConfig.IMME_BOLUS_INFUSION_INFO, info) { it.copy(immeBolusInfusionInfo = info) }
+
+ override fun updateExtendBolusInfusionInfo(info: CarelevoExtendBolusInfusionInfoEntity): Boolean =
+ updateField(PrefEnvConfig.EXTEND_BOLUS_INFUSION_INFO, info) { it.copy(extendBolusInfusionInfo = info) }
+
+ /**
+ * Remove one per-mode record and clear it from the aggregate; the aggregate collapses to
+ * absent when its last record is removed.
+ */
+ private fun deleteField(key: String, mutate: (CarelevoInfusionInfoEntity) -> CarelevoInfusionInfoEntity): Boolean = runCatching {
+ prefManager.remove(key)
+ }.fold(
+ onSuccess = {
+ val infusionInfo = _infusionInfo.value?.getOrNull()?.let(mutate)
+ ?.takeUnless { it.basalInfusionInfo == null && it.tempBasalInfusionInfo == null && it.immeBolusInfusionInfo == null && it.extendBolusInfusionInfo == null }
+ _infusionInfo.onNext(Optional.ofNullable(infusionInfo))
+ true
+ },
+ onFailure = {
+ it.printStackTrace()
+ false
+ }
+ )
+
+ override fun deleteBasalInfusionInfo(): Boolean =
+ deleteField(PrefEnvConfig.BASAL_INFUSION_INFO) { it.copy(basalInfusionInfo = null) }
+
+ override fun deleteTempBasalInfusionInfo(): Boolean =
+ deleteField(PrefEnvConfig.TEMP_BASAL_INFUSION_INFO) { it.copy(tempBasalInfusionInfo = null) }
+
+ override fun deleteImmeBolusInfusionInfo(): Boolean =
+ deleteField(PrefEnvConfig.IMME_BOLUS_INFUSION_INFO) { it.copy(immeBolusInfusionInfo = null) }
+
+ override fun deleteExtendBolusInfusionInfo(): Boolean =
+ deleteField(PrefEnvConfig.EXTEND_BOLUS_INFUSION_INFO) { it.copy(extendBolusInfusionInfo = null) }
+
+ override fun deleteInfusionInfo(): Boolean {
+ return runCatching {
+ prefManager.remove(PrefEnvConfig.BASAL_INFUSION_INFO)
+ prefManager.remove(PrefEnvConfig.TEMP_BASAL_INFUSION_INFO)
+ prefManager.remove(PrefEnvConfig.IMME_BOLUS_INFUSION_INFO)
+ prefManager.remove(PrefEnvConfig.EXTEND_BOLUS_INFUSION_INFO)
+ }.fold(
+ onSuccess = {
+ _infusionInfo.onNext(Optional.ofNullable(null))
+ true
+ },
+ onFailure = {
+ it.printStackTrace()
+ false
+ }
+ )
+ }
+}
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoPatchInfoDao.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoPatchInfoDao.kt
new file mode 100644
index 000000000000..77be32a74eee
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoPatchInfoDao.kt
@@ -0,0 +1,14 @@
+package app.aaps.pump.carelevo.data.dao
+
+import app.aaps.pump.carelevo.data.model.entities.CarelevoPatchInfoEntity
+import io.reactivex.rxjava3.core.Observable
+import java.util.Optional
+
+interface CarelevoPatchInfoDao {
+
+ fun getPatchInfo(): Observable>
+ fun getPatchInfoBySync(): CarelevoPatchInfoEntity?
+
+ fun updatePatchInfo(info: CarelevoPatchInfoEntity): Boolean
+ fun deletePatchInfo(): Boolean
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoPatchInfoDaoImpl.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoPatchInfoDaoImpl.kt
new file mode 100644
index 000000000000..f1aa39569740
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoPatchInfoDaoImpl.kt
@@ -0,0 +1,93 @@
+package app.aaps.pump.carelevo.data.dao
+
+import app.aaps.core.interfaces.sharedPreferences.SP
+
+import app.aaps.pump.carelevo.config.PrefEnvConfig
+import app.aaps.pump.carelevo.data.common.CarelevoGsonHelper
+import app.aaps.pump.carelevo.data.model.entities.CarelevoPatchInfoEntity
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.subjects.BehaviorSubject
+import java.util.Optional
+import javax.inject.Inject
+import kotlin.jvm.optionals.getOrNull
+
+class CarelevoPatchInfoDaoImpl @Inject constructor(
+ private val prefManager: SP
+) : CarelevoPatchInfoDao {
+
+ private val _patchInfo: BehaviorSubject> = BehaviorSubject.create()
+
+ override fun getPatchInfo(): Observable> {
+ if (_patchInfo.value == null) {
+ runCatching {
+ val patchInfoString = prefManager.getString(PrefEnvConfig.PATCH_INFO, "")
+ if (patchInfoString == "") {
+ throw NullPointerException("patch info is empty")
+ }
+ CarelevoGsonHelper.sharedGson().fromJson(patchInfoString, CarelevoPatchInfoEntity::class.java)
+ }.fold(
+ onSuccess = {
+ _patchInfo.onNext(Optional.ofNullable(it))
+ },
+ onFailure = {
+ it.printStackTrace()
+ _patchInfo.onNext(Optional.ofNullable(null))
+ }
+ )
+ }
+ return _patchInfo
+ }
+
+ override fun getPatchInfoBySync(): CarelevoPatchInfoEntity? {
+ if (_patchInfo.value == null) {
+ runCatching {
+ val patchInfoString = prefManager.getString(PrefEnvConfig.PATCH_INFO, "")
+ if (patchInfoString == "") {
+ throw NullPointerException("patch info is empty")
+ }
+ CarelevoGsonHelper.sharedGson().fromJson(patchInfoString, CarelevoPatchInfoEntity::class.java)
+ }.fold(
+ onSuccess = {
+ _patchInfo.onNext(Optional.ofNullable(it))
+ },
+ onFailure = {
+ it.printStackTrace()
+ _patchInfo.onNext(Optional.ofNullable(null))
+ }
+ )
+ }
+
+ return _patchInfo.value?.getOrNull()
+ }
+
+ override fun updatePatchInfo(info: CarelevoPatchInfoEntity): Boolean {
+ return runCatching {
+ val patchInfoString = CarelevoGsonHelper.sharedGson().toJson(info)
+ prefManager.putString(PrefEnvConfig.PATCH_INFO, patchInfoString)
+ }.fold(
+ onSuccess = {
+ _patchInfo.onNext(Optional.ofNullable(info))
+ true
+ },
+ onFailure = {
+ it.printStackTrace()
+ false
+ }
+ )
+ }
+
+ override fun deletePatchInfo(): Boolean {
+ return runCatching {
+ prefManager.remove(PrefEnvConfig.PATCH_INFO)
+ }.fold(
+ onSuccess = {
+ _patchInfo.onNext(Optional.ofNullable(null))
+ true
+ },
+ onFailure = {
+ it.printStackTrace()
+ false
+ }
+ )
+ }
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoUserSettingInfoDao.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoUserSettingInfoDao.kt
new file mode 100644
index 000000000000..c742431c414a
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoUserSettingInfoDao.kt
@@ -0,0 +1,14 @@
+package app.aaps.pump.carelevo.data.dao
+
+import app.aaps.pump.carelevo.data.model.entities.CarelevoUserSettingInfoEntity
+import io.reactivex.rxjava3.core.Observable
+import java.util.Optional
+
+interface CarelevoUserSettingInfoDao {
+
+ fun getUserSetting(): Observable>
+ fun getUserSettingBySync(): CarelevoUserSettingInfoEntity?
+
+ fun updateUserSetting(setting: CarelevoUserSettingInfoEntity): Boolean
+ fun deleteUserSetting(): Boolean
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoUserSettingInfoDaoImpl.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoUserSettingInfoDaoImpl.kt
new file mode 100644
index 000000000000..8ad5896fbcad
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dao/CarelevoUserSettingInfoDaoImpl.kt
@@ -0,0 +1,92 @@
+package app.aaps.pump.carelevo.data.dao
+
+import app.aaps.core.interfaces.sharedPreferences.SP
+import app.aaps.pump.carelevo.config.PrefEnvConfig
+import app.aaps.pump.carelevo.data.common.CarelevoGsonHelper
+import app.aaps.pump.carelevo.data.model.entities.CarelevoUserSettingInfoEntity
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.subjects.BehaviorSubject
+import java.util.Optional
+import javax.inject.Inject
+import kotlin.jvm.optionals.getOrNull
+
+class CarelevoUserSettingInfoDaoImpl @Inject constructor(
+ private val prefManager: SP
+) : CarelevoUserSettingInfoDao {
+
+ private val _userSettingInfo: BehaviorSubject> = BehaviorSubject.create()
+
+ override fun getUserSetting(): Observable> {
+ if (_userSettingInfo.value == null) {
+ runCatching {
+ val userSettingInfoString = prefManager.getString(PrefEnvConfig.USER_SETTING_INFO, "")
+ if (userSettingInfoString == "") {
+ throw NullPointerException("user setting info is empty")
+ }
+ CarelevoGsonHelper.sharedGson().fromJson(userSettingInfoString, CarelevoUserSettingInfoEntity::class.java)
+ }.fold(
+ onSuccess = {
+ _userSettingInfo.onNext(Optional.ofNullable(it))
+ },
+ onFailure = {
+ it.printStackTrace()
+ _userSettingInfo.onNext(Optional.ofNullable(null))
+ }
+ )
+ }
+
+ return _userSettingInfo
+ }
+
+ override fun getUserSettingBySync(): CarelevoUserSettingInfoEntity? {
+ if (_userSettingInfo.value == null) {
+ runCatching {
+ val userSettingInfoString = prefManager.getString(PrefEnvConfig.USER_SETTING_INFO, "")
+ if (userSettingInfoString == "") {
+ throw NullPointerException("user setting info is empty")
+ }
+ CarelevoGsonHelper.sharedGson().fromJson(userSettingInfoString, CarelevoUserSettingInfoEntity::class.java)
+ }.fold(
+ onSuccess = {
+ _userSettingInfo.onNext(Optional.ofNullable(it))
+ },
+ onFailure = {
+ it.printStackTrace()
+ _userSettingInfo.onNext(Optional.ofNullable(null))
+ }
+ )
+ }
+ return _userSettingInfo.value?.getOrNull()
+ }
+
+ override fun updateUserSetting(setting: CarelevoUserSettingInfoEntity): Boolean {
+ return runCatching {
+ val userSettingInfoString = CarelevoGsonHelper.sharedGson().toJson(setting)
+ prefManager.putString(PrefEnvConfig.USER_SETTING_INFO, userSettingInfoString)
+ }.fold(
+ onSuccess = {
+ _userSettingInfo.onNext(Optional.ofNullable(setting))
+ true
+ },
+ onFailure = {
+ it.printStackTrace()
+ false
+ }
+ )
+ }
+
+ override fun deleteUserSetting(): Boolean {
+ return runCatching {
+ prefManager.remove(PrefEnvConfig.USER_SETTING_INFO)
+ }.fold(
+ onSuccess = {
+ _userSettingInfo.onNext(Optional.ofNullable(null))
+ true
+ },
+ onFailure = {
+ it.printStackTrace()
+ false
+ }
+ )
+ }
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoAlarmInfoLocalDataSource.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoAlarmInfoLocalDataSource.kt
new file mode 100644
index 000000000000..c786a93f3bf8
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoAlarmInfoLocalDataSource.kt
@@ -0,0 +1,18 @@
+package app.aaps.pump.carelevo.data.dataSource.local
+
+import app.aaps.pump.carelevo.data.model.entities.CarelevoAlarmInfoEntity
+import io.reactivex.rxjava3.core.Completable
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+import java.util.Optional
+
+interface CarelevoAlarmInfoLocalDataSource {
+
+ fun observeAlarms(): Observable>>
+
+ fun getAlarmsOnce(): Single>>
+ fun setAlarms(list: List): Completable
+ fun upsertAlarm(entity: CarelevoAlarmInfoEntity): Completable
+ fun removeAlarm(alarmId: String): Completable
+ fun clearAlarms(): Completable
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoAlarmInfoLocalDataSourceImpl.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoAlarmInfoLocalDataSourceImpl.kt
new file mode 100644
index 000000000000..fd26274b8009
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoAlarmInfoLocalDataSourceImpl.kt
@@ -0,0 +1,31 @@
+package app.aaps.pump.carelevo.data.dataSource.local
+
+import app.aaps.pump.carelevo.data.dao.CarelevoAlarmInfoDao
+import app.aaps.pump.carelevo.data.model.entities.CarelevoAlarmInfoEntity
+import io.reactivex.rxjava3.core.Completable
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+import java.util.Optional
+import javax.inject.Inject
+
+class CarelevoAlarmInfoLocalDataSourceImpl @Inject constructor(
+ private val dao: CarelevoAlarmInfoDao
+) : CarelevoAlarmInfoLocalDataSource {
+
+ override fun observeAlarms(): Observable>> =
+ dao.getAlarms()
+
+ override fun getAlarmsOnce(): Single>> = dao.getAlarmsOnce()
+
+ override fun setAlarms(list: List): Completable =
+ dao.setAlarms(list)
+
+ override fun upsertAlarm(entity: CarelevoAlarmInfoEntity): Completable =
+ dao.upsertAlarm(entity)
+
+ override fun removeAlarm(alarmId: String): Completable =
+ dao.removeAlarm(alarmId)
+
+ override fun clearAlarms(): Completable =
+ dao.clearAlarms()
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoInfusionInfoDataSource.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoInfusionInfoDataSource.kt
new file mode 100644
index 000000000000..13bc3438bf91
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoInfusionInfoDataSource.kt
@@ -0,0 +1,26 @@
+package app.aaps.pump.carelevo.data.dataSource.local
+
+import app.aaps.pump.carelevo.data.model.entities.CarelevoBasalInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoExtendBolusInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoImmeBolusInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoTempBasalInfusionInfoEntity
+import io.reactivex.rxjava3.core.Observable
+import java.util.Optional
+
+interface CarelevoInfusionInfoDataSource {
+
+ fun getInfusionInfo(): Observable>
+ fun getInfusionInfoBySync(): CarelevoInfusionInfoEntity?
+
+ fun updateBasalInfusionInfo(info: CarelevoBasalInfusionInfoEntity): Boolean
+ fun updateTempBasalInfusionInfo(info: CarelevoTempBasalInfusionInfoEntity): Boolean
+ fun updateImmeBolusInfusionInfo(info: CarelevoImmeBolusInfusionInfoEntity): Boolean
+ fun updateExtendBolusInfusionInfo(info: CarelevoExtendBolusInfusionInfoEntity): Boolean
+
+ fun deleteBasalInfusionInfo(): Boolean
+ fun deleteTempBasalInfusionInfo(): Boolean
+ fun deleteImmeBolusInfusionInfo(): Boolean
+ fun deleteExtendBolusInfusionInfo(): Boolean
+ fun deleteInfusionInfo(): Boolean
+}
\ No newline at end of file
diff --git a/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoInfusionInfoDataSourceImpl.kt b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoInfusionInfoDataSourceImpl.kt
new file mode 100644
index 000000000000..7b81e9fb4c8d
--- /dev/null
+++ b/pump/carelevo/src/main/kotlin/app/aaps/pump/carelevo/data/dataSource/local/CarelevoInfusionInfoDataSourceImpl.kt
@@ -0,0 +1,60 @@
+package app.aaps.pump.carelevo.data.dataSource.local
+
+import app.aaps.pump.carelevo.data.dao.CarelevoInfusionInfoDao
+import app.aaps.pump.carelevo.data.model.entities.CarelevoBasalInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoExtendBolusInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoImmeBolusInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoInfusionInfoEntity
+import app.aaps.pump.carelevo.data.model.entities.CarelevoTempBasalInfusionInfoEntity
+import io.reactivex.rxjava3.core.Observable
+import java.util.Optional
+import javax.inject.Inject
+
+class CarelevoInfusionInfoDataSourceImpl @Inject constructor(
+ private val infusionInfoDao: CarelevoInfusionInfoDao
+) : CarelevoInfusionInfoDataSource {
+
+ override fun getInfusionInfo(): Observable