Reactive dependency injection

Author: wkornewald

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Next release (6.0.0 preview)
 
+* Added reactive dependency injection solution (see `DI`) with graph tracking that can even re-create ViewModels when a DI module/node is changed at runtime.
 * Added `ContextualVal`/`ContextualValSuspend` for coroutine-local variables (like thread-locals or `CompositionLocal` for coroutines).
 * Made the experimental `ReactiveViewModel` more flexible by building it around `ContextualVal`.
 * Changed `loading` and all `withLoading` parameters from `MutableValueFlow` to `MutableStateFlow`.
@@ -14,6 +15,7 @@
 * Fixed `MutableStateFlow.compareAndSet` for `.toMutable`/`.beforeUpdate`/`.afterUpdate`.
 * Added `Flow.stateOnDemand` variant with `initial` value.
 * `CoroutineLauncher.launch` now synchronously increments the loading counter to avoid UI flickering issues in edge cases.
+* Added `childReactiveState` variant which takes an arbitrary event handler, so the parent ReactiveState doesn't have to implement the whole events interface.
 * Removed direct dependency on JUnit 4, so you can choose more freely which JUnit version to use.
 
 ## 5.13.0

build-logic/build-logic-base/src/main/kotlin/com/ensody/buildlogic/KotlinMultiplatformExt.kt

@@ -83,7 +83,6 @@ fun KotlinMultiplatformExtension.applyKmpHierarchy(block: KotlinHierarchyBuilder
                 withWasmJs()
                 withWasmWasi()
                 withIos()
-                withMacos()
                 withJvm()
                 withAndroidTarget()
             }

build-logic/build-logic/src/main/kotlin/com/ensody/buildlogic/BuildLogicPlugin.kt

@@ -102,6 +102,7 @@ fun Project.setupBuildLogic(block: Project.() -> Unit) {
             setupVersionCatalog()
         }
         extensions.findByType<MavenPublishBaseExtension>()?.apply {
+            configureBasedOnAppliedPlugins(sourcesJar = true, javadocJar = System.getenv("RUNNING_ON_CI") == "true")
             publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL, automaticRelease = true)
             if (System.getenv("ORG_GRADLE_PROJECT_signingInMemoryKey")?.isNotBlank() == true) {
                 signAllPublications()

reactivestate-android/src/androidMain/kotlin/com/ensody/reactivestate/AutoRunLiveData.kt

@@ -5,12 +5,12 @@ import androidx.lifecycle.Observer
 
 /** Returns [LiveData.getValue] and tracks the observable. */
 public fun <T> Resolver.get(data: LiveData<T>): T? =
-    track(data) { LiveDataObservable(data, autoRunner) }.value
+    track(data) { LiveDataObservable(data) }.value
 
 private class LiveDataObservable<T>(
     private val data: LiveData<T>,
-    autoRunner: BaseAutoRunner,
 ) : AutoRunnerObservable<T?> {
+    private lateinit var autoRunner: BaseAutoRunner
     private var ignore = false
     private val observer = Observer<T> {
         if (!ignore) {
@@ -20,14 +20,15 @@ private class LiveDataObservable<T>(
 
     override val value: T? get() = data.value
 
-    override fun addObserver() {
+    override fun addObserver(autoRunner: BaseAutoRunner) {
         // Prevent recursion and assume the value is already set correctly
         ignore = true
+        this.autoRunner = autoRunner
         data.observeForever(observer)
         ignore = false
     }
 
-    override fun removeObserver() {
+    override fun removeObserver(autoRunner: BaseAutoRunner) {
         data.removeObserver(observer)
     }
 }

reactivestate-compose/src/composeMain/kotlin/com/ensody/reactivestate/compose/ViewModelExt.kt

@@ -2,9 +2,9 @@ package com.ensody.reactivestate.compose
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.mutableStateMapOf
+import androidx.compose.runtime.State
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.snapshots.SnapshotStateMap
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelStoreOwner
 import androidx.lifecycle.viewModelScope
@@ -14,32 +14,43 @@ import com.ensody.reactivestate.ContextualErrorsFlow
 import com.ensody.reactivestate.ContextualStateFlowStore
 import com.ensody.reactivestate.ContextualValRoot
 import com.ensody.reactivestate.CoroutineLauncher
+import com.ensody.reactivestate.DI
 import com.ensody.reactivestate.ExperimentalReactiveStateApi
 import com.ensody.reactivestate.InMemoryStateFlowStore
 import com.ensody.reactivestate.ReactiveStateContext
+import com.ensody.reactivestate.invokeOnCompletion
 import com.ensody.reactivestate.triggerOnInit
+import com.ensody.reactivestate.withSpinLock
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.plus
+import kotlinx.coroutines.sync.Mutex
 
 /**
  * Creates a multiplatform ViewModel. The [provider] should instantiate the object directly.
  *
  * You have to pass loading and error effect handlers, so the most basic functionality is taken care of.
+ *
+ * Instead of returning the raw ViewModel this returns a Compose [State] object containing the ViewModel.
+ * This way the UI can keep up to date with a dynamically changing dependency injection graph.
+ * If the ViewModel depends on a [DI] object it gets destroyed and re-created whenever that DI module is replaced.
  */
 @ExperimentalReactiveStateApi
 @Composable
 public inline fun <reified VM : CoroutineLauncher> reactiveViewModel(
     key: String? = null,
     crossinline onError: (Throwable) -> Unit,
     crossinline provider: ReactiveStateContext.() -> VM,
-): VM =
+): State<VM> =
     onViewModel(key = key) {
         provider().also {
             it.triggerOnInit()
         }
     }.also { viewModel ->
-        LaunchedEffect(viewModel) {
-            ContextualErrorsFlow.get(viewModel.scope).collect { onError(it) }
+        LaunchedEffect(viewModel.value) {
+            ContextualErrorsFlow.get(viewModel.value.scope).collect { onError(it) }
         }
     }
 
@@ -58,20 +69,38 @@ public inline fun <reified T : Any?> onViewModel(
     },
     key: String? = null,
     crossinline provider: ReactiveStateContext.() -> T,
-): T {
+): State<T> {
     // TODO: Use qualifiedName once JS supports it
     val fullKey = (key ?: "") + ":onViewModel:${T::class.simpleName}"
-    val storage = rememberSaveable<SnapshotStateMap<String, Any?>> { mutableStateMapOf() }
+    val storage = rememberSaveable<MutableMap<String, Any?>> { mutableMapOf() }
     return viewModel(viewModelStoreOwner = viewModelStoreOwner, key = fullKey) {
-        WrapperViewModel { scope ->
-            ReactiveStateContext(
-                scope + ContextualValRoot() + ContextualStateFlowStore.valued { InMemoryStateFlowStore(storage) },
-            ).provider()
+        WrapperViewModel { viewModelScope ->
+            // The viewModelScope can't be used directly because we have to destroy and re-create the ViewModel whenever
+            // the DI graph gets modified.
+            val mutex = Mutex()
+            var scope: CoroutineScope? = null
+            viewModelScope.invokeOnCompletion {
+                mutex.withSpinLock {
+                    scope?.cancel()
+                    scope = null
+                }
+            }
+            DI.derived {
+                val vmScope = MainScope()
+                mutex.withSpinLock {
+                    scope?.cancel()
+                    scope = vmScope
+                }
+                ReactiveStateContext(
+                    vmScope + ContextualValRoot() + ContextualStateFlowStore.valued { InMemoryStateFlowStore(storage) },
+                    this,
+                ).provider()
+            }
         }
-    }.value
+    }.value.collectAsState()
 }
 
 /** A wrapper ViewModel used to hold an arbitrary [value]. */
-public class WrapperViewModel<T : Any?>(provider: (CoroutineScope) -> T) : ViewModel() {
-    public val value: T = provider(viewModelScope)
+public class WrapperViewModel<T : Any?>(provider: (CoroutineScope) -> StateFlow<T>) : ViewModel() {
+    public val value: StateFlow<T> = provider(viewModelScope)
 }

reactivestate-core/src/commonMain/kotlin/com/ensody/reactivestate/Annotations.kt

@@ -15,3 +15,12 @@ public annotation class ExperimentalReactiveStateApi
 @Retention(value = AnnotationRetention.BINARY)
 @Target(AnnotationTarget.PROPERTY)
 public annotation class DependencyAccessor
+
+/** Marks internal ReactiveState APIs. */
+@MustBeDocumented
+@RequiresOptIn(
+    message = "Internal API. Don't use this.",
+    level = RequiresOptIn.Level.ERROR,
+)
+@Retention(value = AnnotationRetention.BINARY)
+public annotation class InternalReactiveStateApi

reactivestate-core/src/commonMain/kotlin/com/ensody/reactivestate/AutoRun.kt

@@ -126,7 +126,7 @@ public fun CoroutineScope.coAutoRun(
 
 /** Just the minimum interface needed for [Resolver]. No generic types. */
 public abstract class BaseAutoRunner : AttachedDisposables {
-    internal abstract val resolver: Resolver
+    internal abstract val resolver: ResolverImpl
     public abstract val launcher: CoroutineLauncher
 
     public abstract fun triggerChange()
@@ -140,7 +140,7 @@ public abstract class InternalBaseAutoRunner(
     private val immediate: Boolean,
 ) : BaseAutoRunner() {
     override val attachedDisposables: DisposableGroup = DisposableGroup()
-    override var resolver: Resolver = Resolver(this)
+    override var resolver: ResolverImpl = ResolverImpl(this)
         internal set
     protected open val withLoading: MutableStateFlow<Int>? = null
 
@@ -182,7 +182,7 @@ public abstract class InternalBaseAutoRunner(
     /** Stops watching observables. */
     override fun dispose() {
         flowConsumer?.cancel()
-        resolver = Resolver(this).also(resolver::switchTo)
+        resolver = ResolverImpl(this).also(resolver::switchTo)
         flowConsumer = null
         super.dispose()
     }
@@ -233,10 +233,10 @@ public class AutoRunner<T>(
     }
 
     private fun <T> observe(once: Boolean, observer: AutoRunCallback<T>): T {
-        if (once) return Resolver(this, once).observer()
+        if (once) return ResolverImpl(this, once).observer()
 
         val previousResolver = resolver
-        val nextResolver = Resolver(this)
+        val nextResolver = ResolverImpl(this)
         try {
             return nextResolver.observer()
         } finally {
@@ -285,7 +285,7 @@ public class CoAutoRunner<T>(
 ) : InternalBaseAutoRunner(launcher, flowTransformer, immediate) {
     override val attachedDisposables: DisposableGroup = DisposableGroup()
     private val listener: CoAutoRunOnChangeCallback<T> = onChange ?: { run() }
-    override var resolver: Resolver = Resolver(this)
+    override var resolver: ResolverImpl = ResolverImpl(this)
 
     init {
         init()
@@ -303,10 +303,10 @@ public class CoAutoRunner<T>(
     }
 
     private suspend fun <T> observe(once: Boolean, observer: CoAutoRunCallback<T>): T {
-        if (once) return Resolver(this, once).observer()
+        if (once) return ResolverImpl(this, once).observer()
 
         val previousResolver = resolver
-        val nextResolver = Resolver(this)
+        val nextResolver = ResolverImpl(this)
         try {
             return nextResolver.observer()
         } finally {
@@ -323,8 +323,31 @@ public class CoAutoRunner<T>(
 }
 
 /** Tracks observables for [AutoRunner] and [CoAutoRunner]. */
-public class Resolver(public val autoRunner: BaseAutoRunner, public val once: Boolean = false) {
-    internal val observables = mutableMapOf<Any, FrozenAutoRunnerObservable<*, *>>()
+public interface Resolver {
+    public val autoRunner: BaseAutoRunner
+
+    @InternalReactiveStateApi
+    public val InternalResolver.once: Boolean
+
+    public fun <S : Any, T : AutoRunnerObservable<V>, V> track(
+        underlyingObservable: S,
+        getObservable: () -> T,
+    ): FrozenAutoRunnerObservable<V, T>
+
+    @InternalReactiveStateApi
+    public val InternalResolver.observables: Map<Any, FrozenAutoRunnerObservable<*, *>>
+}
+
+@InternalReactiveStateApi
+public object InternalResolver
+
+@OptIn(InternalReactiveStateApi::class)
+internal class ResolverImpl(override val autoRunner: BaseAutoRunner, private val once: Boolean = false) : Resolver {
+    override val InternalResolver.once: Boolean
+        get() = this@ResolverImpl.once
+    private val observables = mutableMapOf<Any, FrozenAutoRunnerObservable<*, *>>()
+    override val InternalResolver.observables: Map<Any, FrozenAutoRunnerObservable<*, *>>
+        get() = this@ResolverImpl.observables
 
     /**
      * Tracks an arbitrary observable.
@@ -337,7 +360,7 @@ public class Resolver(public val autoRunner: BaseAutoRunner, public val once: Bo
      *
      * @return The instantiated [AutoRunnerObservable] of type [T].
      */
-    public fun <S : Any, T : AutoRunnerObservable<V>, V> track(
+    override fun <S : Any, T : AutoRunnerObservable<V>, V> track(
         underlyingObservable: S,
         getObservable: () -> T,
     ): FrozenAutoRunnerObservable<V, T> {
@@ -348,16 +371,16 @@ public class Resolver(public val autoRunner: BaseAutoRunner, public val once: Bo
         val observable = FrozenAutoRunnerObservable<V, T>(castExisting ?: getObservable())
         observables[underlyingObservable] = observable
         if (!once && autoRunner.isActive && castExisting == null) {
-            observable.observable.addObserver()
-            existing?.observable?.removeObserver()
+            observable.observable.addObserver(autoRunner)
+            existing?.observable?.removeObserver(autoRunner)
         }
         return observable
     }
 
-    internal fun switchTo(next: Resolver) {
+    internal fun switchTo(next: ResolverImpl) {
         for ((underlyingObservable, item) in observables) {
             if (item.observable != next.observables[underlyingObservable]?.observable) {
-                item.observable.removeObserver()
+                item.observable.removeObserver(autoRunner)
             }
         }
     }
@@ -371,8 +394,8 @@ public class Resolver(public val autoRunner: BaseAutoRunner, public val once: Bo
 public interface AutoRunnerObservable<T> {
     public val value: T
     public val revisionedValue: Pair<T, ULong> get() = value to 0U
-    public fun addObserver()
-    public fun removeObserver()
+    public fun addObserver(autoRunner: BaseAutoRunner)
+    public fun removeObserver(autoRunner: BaseAutoRunner)
 }
 
 public class FrozenAutoRunnerObservable<T, O : AutoRunnerObservable<T>>(

reactivestate-core/src/commonMain/kotlin/com/ensody/reactivestate/AutoRunStateFlow.kt

@@ -5,21 +5,20 @@ import kotlinx.coroutines.flow.StateFlow
 
 /** Returns [StateFlow.value] and tracks the observable (on the `MainScope`). */
 public fun <T> Resolver.get(data: StateFlow<T>): T =
-    track(data) { StateFlowObservable(data, autoRunner) }.value
+    track(data) { StateFlowObservable(data) }.value
 
 private class StateFlowObservable<T>(
     private val data: StateFlow<T>,
-    private val autoRunner: BaseAutoRunner,
 ) : AutoRunnerObservable<T> {
     private var observer: Job? = null
 
     override val value: T get() = data.value
 
     @Suppress("UNCHECKED_CAST")
     override val revisionedValue: Pair<T, ULong>
-        get() = (data as? RevisionedValue<T>)?.revisionedValue ?: value to 0U
+        get() = (data as? RevisionedValue<T>)?.revisionedValue ?: (value to 0U)
 
-    override fun addObserver() {
+    override fun addObserver(autoRunner: BaseAutoRunner) {
         if (observer == null) {
             var ignore: Wrapped<T>? = Wrapped(data.value)
             observer = autoRunner.launcher.launch(withLoading = null) {
@@ -33,7 +32,7 @@ private class StateFlowObservable<T>(
         }
     }
 
-    override fun removeObserver() {
+    override fun removeObserver(autoRunner: BaseAutoRunner) {
         observer?.cancel()
         observer = null
     }

reactivestate-core/src/commonMain/kotlin/com/ensody/reactivestate/AutoRunWhileUsed.kt

@@ -12,13 +12,13 @@ private class WhileUsedObservable<T>(
 ) : AutoRunnerObservable<DisposableValue<T>?> {
     override var value: DisposableValue<T>? = null
 
-    override fun addObserver() {
+    override fun addObserver(autoRunner: BaseAutoRunner) {
         if (value == null) {
             value = data.disposableValue()
         }
     }
 
-    override fun removeObserver() {
+    override fun removeObserver(autoRunner: BaseAutoRunner) {
         value?.dispose()
     }
 }