Implement insulin on board value

app/build.gradle.kts

@@ -32,6 +32,7 @@ kotlin {
 
             implementation(libs.androidx.datastore.core)
             implementation(libs.androidx.datastore.preferences)
+            implementation(libs.commons.math3)
 
             configurations["kspAndroid"].dependencies.add(project.dependencies.create(libs.hilt.android.compiler.get()))
         }
@@ -74,6 +75,7 @@ kotlin {
             implementation(libs.androidx.room.common)
             implementation(libs.androidx.room.runtime)
             implementation(libs.androidx.sqlite.bundled)
+            implementation(libs.commons.math3)
         }
 
         val desktopMain by getting {

app/src/androidMain/kotlin/net/cacheux/nvp/app/MainActivity.kt

@@ -57,11 +57,16 @@ class MainActivity : ComponentActivity() {
                                 groupDelay = settingsViewModel.groupDelay.asStateWrapper(),
                                 autoIgnoreEnabled = settingsViewModel.autoIgnoreEnabled.asStateWrapper(),
                                 autoIgnoreValue = settingsViewModel.autoIgnoreValue.asStateWrapper(),
+                                groupIoB = settingsViewModel.groupIoB.asStateWrapper(),
+                                insulinPeak = settingsViewModel.insulinPeak.asStateWrapper(),
+                                delta = settingsViewModel.delta.asStateWrapper(),
+                                insulinDuration = settingsViewModel.insulinDuration.asStateWrapper()
                             )
                         )
                     } else {
                         MainScreen(
                             doseList = viewModel.doseList.collectAsState(listOf()).value.reversed(),
+                            iob = viewModel.iob.collectAsState(null).value,
                             message = viewModel.getReadMessage().collectAsState().value,
 
                             loading = viewModel.isReading().collectAsState().value,

app/src/androidMain/kotlin/net/cacheux/nvp/app/MainScreenViewModel.kt

@@ -7,16 +7,20 @@ import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.launch
 import net.cacheux.nvp.app.utils.csvToDoseList
 import net.cacheux.nvp.logging.logDebug
 import net.cacheux.nvp.model.Dose
 import net.cacheux.nvp.model.DoseGroup
+import net.cacheux.nvp.model.IoB
 import java.io.InputStream
+import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 
 @HiltViewModel
@@ -33,6 +37,8 @@ class MainScreenViewModel @Inject constructor(
         preferencesRepository
     )
 
+    private val iobUseCase: IoBUseCase = IoBUseCase(preferencesRepository)
+
     fun getPenList() = storageRepository.getPenList()
 
     private val isReading = MutableStateFlow(false)
@@ -64,6 +70,14 @@ class MainScreenViewModel @Inject constructor(
         storageRepository.getDoseList(it)
     }
 
+    val iob: Flow<IoB?> = iobUseCase.calculate(doseList, flow {
+        while(true) {
+            emit(System.currentTimeMillis())
+            delay(TimeUnit.MINUTES.toMillis(1))
+        }
+    })
+
+
     val store = repository.getDataStore()
 
     fun loadCsvFile(input: InputStream) {

app/src/androidMain/kotlin/net/cacheux/nvp/app/SettingsViewModel.kt

@@ -12,4 +12,9 @@ class SettingsViewModel @Inject constructor(
     val groupDelay = preferencesRepository.groupDelay
     val autoIgnoreEnabled = preferencesRepository.autoIgnoreEnabled
     val autoIgnoreValue = preferencesRepository.autoIgnoreValue
+
+    val groupIoB = preferencesRepository.groupIoB
+    val insulinPeak = preferencesRepository.insulinPeak
+    val delta = preferencesRepository.delta
+    val insulinDuration = preferencesRepository.insulinDuration
 }

app/src/androidMain/kotlin/net/cacheux/nvp/app/repository/DatastorePreferencesRepository.kt

@@ -18,6 +18,10 @@ class DatastorePreferencesRepository(context: Context): PreferencesRepository {
         val GROUP_DELAY = intPreferencesKey("group_delay")
         val AUTO_IGNORE_ENABLED = booleanPreferencesKey("auto_ignore_enabled")
         val AUTO_IGNORE_VALUE = intPreferencesKey("auto_ignore_value")
+        val GROUP_IOB = booleanPreferencesKey("group_iob")
+        val IOB_INSULIN_PEAK = intPreferencesKey("iob_insulin_peak")
+        val IOB_DELTA = intPreferencesKey("iob_delta")
+        val IOB_INSULIN_DURATION = intPreferencesKey("iob_insulin_duration")
     }
 
     override val groupEnabled: StateFlowWrapper<Boolean> =
@@ -39,4 +43,20 @@ class DatastorePreferencesRepository(context: Context): PreferencesRepository {
         PreferenceStateFlowWrapper(
             dataStore, PreferencesKeys.AUTO_IGNORE_VALUE, 2
         )
+
+    override val groupIoB: StateFlowWrapper<Boolean> = PreferenceStateFlowWrapper(
+        dataStore, PreferencesKeys.GROUP_IOB, false
+    )
+
+    override val insulinPeak: StateFlowWrapper<Int> = PreferenceStateFlowWrapper(
+        dataStore, PreferencesKeys.IOB_INSULIN_PEAK, 75
+    )
+
+    override val delta: StateFlowWrapper<Int> = PreferenceStateFlowWrapper(
+        dataStore, PreferencesKeys.IOB_DELTA, 15
+    )
+
+    override val insulinDuration: StateFlowWrapper<Int> = PreferenceStateFlowWrapper(
+        dataStore, PreferencesKeys.IOB_INSULIN_DURATION, 5
+    )
 }

app/src/commonMain/kotlin/net/cacheux/nvp/app/IoBUseCase.kt

@@ -0,0 +1,89 @@
+package net.cacheux.nvp.app
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
+import net.cacheux.nvp.model.DoseGroup
+import net.cacheux.nvp.model.InsulinUnit
+import net.cacheux.nvp.model.IoB
+import java.util.concurrent.TimeUnit
+import org.apache.commons.math3.special.Gamma
+
+class IoBUseCase(
+    private val preferencesRepository: PreferencesRepository,
+    private val scope: CoroutineScope = CoroutineScope(Dispatchers.IO)
+) {
+    // How fast insulin is absorbed (Novorapid: 1.5)
+    val absorptionRate: Double = 1.5
+
+
+    fun calculate(doseGroups: Flow<List<DoseGroup>>, time: Flow<Long>): Flow<IoB?> {
+        return combine(
+            doseGroups,
+            time,
+            preferencesRepository.groupIoB.content,
+            preferencesRepository.insulinPeak.content.map { TimeUnit.MINUTES.toMillis(it.toLong()) },
+            preferencesRepository.delta.content.map { TimeUnit.MINUTES.toMillis(it.toLong()) },
+            preferencesRepository.insulinDuration.content.map { TimeUnit.HOURS.toMillis(it.toLong()) },
+        ) { values ->
+            val doseGroups = values[0] as List<DoseGroup>
+            val time = values[1] as Long
+            val enabled = values[2] as Boolean
+            val insulinPeak = values[3] as Long
+            val delta = values[4] as Long
+            val insulinDuration = values[5] as Long
+
+            if (!enabled) {
+                return@combine null
+            }
+
+            val nextTime = time + delta
+
+            val remaining =
+                doseGroups
+                    .sortedByDescending { it.getTime() }
+                    .takeWhile { time - it.getTime() <= insulinDuration }
+                    .map {
+                        (it.getTotal() * this.fraction(
+                            time,
+                            it.getTime(),
+                            insulinPeak
+                        )).toInt()
+                    }
+
+            val next =
+                doseGroups
+                    .sortedByDescending { it.getTime() }
+                    .takeWhile { nextTime - it.getTime() <= insulinDuration }
+                    .map {
+                        (it.getTotal() * (this.fraction(
+                            time,
+                            it.getTime(),
+                            insulinPeak
+                        ) - this.fraction(nextTime, it.getTime(), insulinPeak))).toInt()
+                    }
+
+            IoB(
+                time = time,
+                remaining = InsulinUnit(remaining.sum()),
+                serial = doseGroups.lastOrNull()?.getSerial() ?: "",
+                current = InsulinUnit(next.sum()),
+                delta = delta
+            )
+        }
+    }
+
+    fun fraction(
+        time: Long,
+        doseTime: Long,
+        insulinPeak: Long,
+    ): Double {
+        val timeSinceBolus = time - doseTime
+        val x = absorptionRate * timeSinceBolus / insulinPeak
+        val r = Gamma.regularizedGammaQ(absorptionRate + 1, x)
+
+        return r
+    }
+}

app/src/commonMain/kotlin/net/cacheux/nvp/app/PreferencesRepository.kt

@@ -7,4 +7,12 @@ interface PreferencesRepository {
     val groupDelay: StateFlowWrapper<Int>
     val autoIgnoreEnabled: StateFlowWrapper<Boolean>
     val autoIgnoreValue: StateFlowWrapper<Int>
+
+    val groupIoB: StateFlowWrapper<Boolean>
+    // Time to peak insulin activity (Novorapid: 75 minutes)
+    val insulinPeak: StateFlowWrapper<Int>
+    // Time period to calculate amount of current active insulin
+    val delta: StateFlowWrapper<Int>
+    // How old doses is calculated (Novorapid: 5 hours)
+    val insulinDuration: StateFlowWrapper<Int>
 }

app/src/desktopMain/kotlin/main.kt

@@ -15,6 +15,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import net.cacheux.nvp.app.DoseListUseCase
+import net.cacheux.nvp.app.IoBUseCase
 import net.cacheux.nvp.app.MainScreenViewModel
 import net.cacheux.nvp.app.SettingsViewModel
 import net.cacheux.nvp.app.StorageRepository
@@ -42,7 +43,8 @@ val preferencesRepository = PreferencesRepositoryImpl()
 val mainScreenViewModel = MainScreenViewModel(
     TestPenInfoRepository(),
     doseListUseCase = DoseListUseCase(storageRepository, preferencesRepository),
-    storageRepository = storageRepository
+    storageRepository = storageRepository,
+    iobUseCase = IoBUseCase(preferencesRepository)
 )
 
 val settingsViewModel = SettingsViewModel(preferencesRepository)
@@ -93,6 +95,8 @@ fun main() = application {
         } else {
             MainScreen(
                 doseList = mainScreenViewModel.doseList.collectAsState(listOf()).value.reversed(),
+                iob = mainScreenViewModel.iob.collectAsState(null).value,
+
                 loadingFileAvailable = true,
 
                 loading = mainScreenViewModel.isReading().collectAsState().value,

app/src/desktopMain/kotlin/net/cacheux/nvp/app/MainScreenViewModel.kt

@@ -4,23 +4,28 @@ import io.github.vinceglb.filekit.core.PlatformFile
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.launch
 import net.cacheux.nvp.app.utils.csvToDoseList
 import net.cacheux.nvp.logging.logDebug
 import net.cacheux.nvp.model.Dose
 import net.cacheux.nvp.model.DoseGroup
+import net.cacheux.nvp.model.IoB
 import net.cacheux.nvplib.NvpController
 import net.cacheux.nvplib.testing.TestingDataReader
 import java.nio.charset.Charset
+import java.util.concurrent.TimeUnit
 
 class MainScreenViewModel(
     private val repository: PenInfoRepository,
     private val storageRepository: StorageRepository,
     private val doseListUseCase: DoseListUseCase,
+    private val iobUseCase: IoBUseCase,
     private val coroutineScope: CoroutineScope = CoroutineScope(Dispatchers.IO)
 ) {
     fun getPenList() = storageRepository.getPenList()
@@ -54,6 +59,13 @@ class MainScreenViewModel(
         storageRepository.getDoseList(it)
     }
 
+    val iob: Flow<IoB?> = iobUseCase.calculate(doseList, flow {
+        while(true) {
+            emit(System.currentTimeMillis())
+            delay(TimeUnit.MINUTES.toMillis(1))
+        }
+    })
+
     val store = repository.getDataStore()
 
     fun loadCsvFile(file: PlatformFile) {

app/src/desktopMain/kotlin/net/cacheux/nvp/app/repository/PreferencesRepositoryImpl.kt

@@ -20,6 +20,11 @@ class PreferencesRepositoryImpl: PreferencesRepository {
     override val autoIgnoreEnabled = booleanStateFlowWrapper("autoIgnoreEnabled", "true")
     override val autoIgnoreValue = intStateFlowWrapper("autoIgnoreValue", "2")
 
+    override val groupIoB = booleanStateFlowWrapper("groupIoB", "false")
+    override val insulinPeak = intStateFlowWrapper("insulinPeak", "75")
+    override val delta = intStateFlowWrapper("delta", "15")
+    override val insulinDuration = intStateFlowWrapper("insulinDuration", "5")
+
     private fun saveProperties() {
         propertiesFile.outputStream().use { properties.store(it, null) }
     }

gradle/libs.versions.toml

@@ -12,6 +12,8 @@ compose-compiler = "1.5.14"
 room = "2.7.0-alpha11"
 sqlite = "2.5.0-SNAPSHOT"
 androidx-datastore = "1.1.1"
+commons-math = "3.6.1"
+
 
 [plugins]
 ksp = { id = "com.google.devtools.ksp", version = "1.9.24-1.0.20" }
@@ -35,6 +37,7 @@ appcompat = { group = "androidx.appcompat", name = "appcompat", version = "1.7.0
 androidx-activity-compose = { module = "androidx.activity:activity-compose", version = "1.9.3" }
 androidx-datastore-preferences = { module = "androidx.datastore:datastore-preferences", version = "androidx-datastore" }
 androidx-datastore-core = { module = "androidx.datastore:datastore-core", version.ref = "androidx-datastore" }
+commons-math3 = { group = "org.apache.commons", name = "commons-math3", version.ref = "commons-math" }
 # Room
 androidx-room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
 androidx-room-common = { group = "androidx.room", name = "room-common", version.ref = "room" }

model/src/commonMain/kotlin/net/cacheux/nvp/model/Dose.kt

@@ -8,7 +8,7 @@ data class Dose(
 ): DatedItem {
     fun ignored() = Dose(time, value, true, serial)
 
-    fun displayedValue() = String.format("%.1f", value.toFloat() / 10)
+    fun displayedValue() = String.format("%.1f", InsulinUnit(value).toFloat())
 
     /**
      * Compare with another without the ignored field

model/src/commonMain/kotlin/net/cacheux/nvp/model/InsulinUnit.kt

@@ -0,0 +1,16 @@
+package net.cacheux.nvp.model
+
+@JvmInline
+value class InsulinUnit(private val v: Int) {
+    constructor(f: Float) : this((f * 10).toInt())
+    constructor(f: Double) : this((f * 10).toInt())
+
+    fun toFloat() = v.toFloat() / 10
+    fun toInt() = v
+
+    operator fun minus(other: InsulinUnit): InsulinUnit {
+        return InsulinUnit(this.v - other.v)
+    }
+}
+
+

model/src/commonMain/kotlin/net/cacheux/nvp/model/IoB.kt

@@ -0,0 +1,9 @@
+package net.cacheux.nvp.model
+
+data class IoB(
+    val time: Long,
+    val remaining: InsulinUnit,
+    val current: InsulinUnit,
+    val delta: Long,
+    val serial: String = ""
+)

ui/src/commonMain/composeResources/values-fr/strings.xml

@@ -10,6 +10,8 @@
     <string name="export_csv">Exporter au format CSV</string>
     <string name="import_csv">Importer un fichier CSV</string>
     <string name="back_button">Bouton retour</string>
+    <string name="insulin_on_board">Insuline à bord :</string>
+    <string name="active_insulin">Active :</string>
 
     <string name="ok">OK</string>
     <string name="cancel">Annuler</string>
@@ -24,4 +26,14 @@
     <string name="auto_ignore_details">Les valeurs en dessous de la valeur spécifiée ne seront pas comptées</string>
     <string name="auto_ignore_value">En dessous de</string>
     <string name="auto_ignore_value_suffix"> unités</string>
+
+    <string name="group_iob">Insuline à bord</string>
+    <string name="group_iob_details">Afficher l'insuline active</string>
+    <string name="group_iob_insulin_peak">Période de pic d'insuline (min)</string>
+    <string name="group_iob_delta">Période de calcul de l'insuline active (min)</string>
+    <string name="group_iob_insulin_duration">Durée de l'insuline (heures)</string>
+
+    <string name="minutes_suffix"> minutes</string>
+    <string name="hours_suffix"> heures</string>
+
 </resources>