[Architecture] experiments to remove DI graph managements from navigation flow nodes

app/src/main/kotlin/io/element/android/x/MainActivity.kt

@@ -25,11 +25,9 @@ import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.WindowCompat
 import com.bumble.appyx.core.integration.NodeHost
 import com.bumble.appyx.core.integrationpoint.NodeComponentActivity
-import io.element.android.x.di.AppBindings
 import io.element.android.libraries.architecture.bindings
-import io.element.android.libraries.architecture.createNode
 import io.element.android.libraries.designsystem.theme.ElementTheme
-import io.element.android.x.node.RootFlowNode
+import io.element.android.x.di.AppBindings
 
 class MainActivity : NodeComponentActivity() {
 
@@ -45,7 +43,7 @@ class MainActivity : NodeComponentActivity() {
                     modifier = Modifier.fillMaxSize(),
                 ) {
                     NodeHost(integrationPoint = appyxIntegrationPoint) {
-                        createNode<RootFlowNode>(it)
+                        MainNode(it, appBindings.mainDaggerComponentOwner())
                     }
                 }
             }

app/src/main/kotlin/io/element/android/x/MainNode.kt

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.composable.Children
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.navigation.model.permanent.PermanentNavModel
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.node.ParentNode
+import io.element.android.libraries.architecture.bindings
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.DaggerComponentOwner
+import io.element.android.libraries.matrix.MatrixClient
+import io.element.android.libraries.matrix.room.MatrixRoom
+import io.element.android.x.di.MainDaggerComponentOwner
+import io.element.android.x.di.RoomComponent
+import io.element.android.x.di.SessionComponent
+import io.element.android.x.node.LoggedInFlowNode
+import io.element.android.x.node.RoomFlowNode
+import io.element.android.x.node.RootFlowNode
+
+class MainNode(
+    buildContext: BuildContext,
+    private val mainDaggerComponentOwner: MainDaggerComponentOwner,
+) :
+    ParentNode<MainNode.NavTarget>(
+        navModel = PermanentNavModel(
+            navTargets = setOf(NavTarget),
+            savedStateMap = buildContext.savedStateMap,
+        ),
+        buildContext = buildContext,
+    ),
+    DaggerComponentOwner by mainDaggerComponentOwner {
+
+    private val loggedInFlowNodeCallback = object : LoggedInFlowNode.LifecycleCallback {
+        override fun onFlowCreated(client: MatrixClient) {
+            val component = bindings<SessionComponent.ParentBindings>().sessionComponentBuilder().client(client).build()
+            mainDaggerComponentOwner.addComponent(client.sessionId.value, component)
+        }
+
+        override fun onFlowReleased(client: MatrixClient) {
+            mainDaggerComponentOwner.removeComponent(client.sessionId.value)
+        }
+    }
+
+    private val roomFlowNodeCallback = object : RoomFlowNode.LifecycleCallback {
+        override fun onFlowCreated(room: MatrixRoom) {
+            val component = bindings<RoomComponent.ParentBindings>().roomComponentBuilder().room(room).build()
+            mainDaggerComponentOwner.addComponent(room.roomId.value, component)
+        }
+
+        override fun onFlowReleased(room: MatrixRoom) {
+            mainDaggerComponentOwner.removeComponent(room.roomId.value)
+        }
+    }
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        return createNode<RootFlowNode>(buildContext, plugins = listOf(loggedInFlowNodeCallback, roomFlowNodeCallback))
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Children(navModel = navModel)
+    }
+
+    object NavTarget
+}

app/src/main/kotlin/io/element/android/x/di/AppBindings.kt

@@ -22,4 +22,5 @@ import io.element.android.libraries.di.AppScope
 @ContributesTo(AppScope::class)
 interface AppBindings {
     fun matrixClientsHolder(): MatrixClientsHolder
+    fun mainDaggerComponentOwner(): MainDaggerComponentOwner
 }

app/src/main/kotlin/io/element/android/x/di/MainDaggerComponentOwner.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.di
+
+import android.content.Context
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.ApplicationContext
+import io.element.android.libraries.di.DaggerComponentOwner
+import io.element.android.libraries.di.SingleIn
+import javax.inject.Inject
+
+@SingleIn(AppScope::class)
+class MainDaggerComponentOwner @Inject constructor(@ApplicationContext context: Context) : DaggerComponentOwner {
+
+    private val daggerComponents = LinkedHashMap<String, Any>().apply {
+        put("app", (context as DaggerComponentOwner).daggerComponent)
+    }
+
+    fun addComponent(identifier: String, component: Any) {
+        daggerComponents[identifier] = component
+    }
+
+    fun removeComponent(identifier: String) {
+        daggerComponents.remove(identifier)
+    }
+
+    override val daggerComponent: Any
+        get() = daggerComponents.values.reversed()
+}

app/src/main/kotlin/io/element/android/x/di/SessionComponent.kt

@@ -28,7 +28,7 @@ import io.element.android.libraries.matrix.MatrixClient
 
 @SingleIn(SessionScope::class)
 @MergeSubcomponent(SessionScope::class)
-interface SessionComponent : NodeFactoriesBindings, RoomComponent.ParentBindings {
+interface SessionComponent : NodeFactoriesBindings {
 
     @Subcomponent.Builder
     interface Builder {

app/src/main/kotlin/io/element/android/x/node/LoggedInFlowNode.kt

@@ -46,11 +46,9 @@ import io.element.android.libraries.architecture.nodeInputs
 import io.element.android.libraries.architecture.nodeInputsProvider
 import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.di.AppScope
-import io.element.android.libraries.di.DaggerComponentOwner
 import io.element.android.libraries.matrix.MatrixClient
 import io.element.android.libraries.matrix.core.RoomId
 import io.element.android.libraries.matrix.ui.di.MatrixUIBindings
-import io.element.android.x.di.SessionComponent
 import kotlinx.parcelize.Parcelize
 
 @ContributesNode(AppScope::class)
@@ -66,10 +64,16 @@ class LoggedInFlowNode @AssistedInject constructor(
     ),
     buildContext = buildContext,
     plugins = plugins
-), DaggerComponentOwner {
+) {
 
     interface Callback : Plugin {
-        fun onOpenBugReport()
+        fun onOpenBugReport() = Unit
+    }
+
+    interface LifecycleCallback : NodeLifecycleCallback {
+        fun onFlowCreated(client: MatrixClient) = Unit
+
+        fun onFlowReleased(client: MatrixClient) = Unit
     }
 
     data class Inputs(
@@ -78,19 +82,17 @@ class LoggedInFlowNode @AssistedInject constructor(
 
     private val inputs: Inputs by nodeInputs()
 
-    override val daggerComponent: Any by lazy {
-        parent!!.bindings<SessionComponent.ParentBindings>().sessionComponentBuilder().client(inputs.matrixClient).build()
-    }
-
     override fun onBuilt() {
         super.onBuilt()
         lifecycle.subscribe(
             onCreate = {
+                plugins<LifecycleCallback>().forEach { it.onFlowCreated(inputs.matrixClient) }
                 val imageLoaderFactory = bindings<MatrixUIBindings>().loggedInImageLoaderFactory()
                 Coil.setImageLoader(imageLoaderFactory)
                 inputs.matrixClient.startSync()
             },
             onDestroy = {
+                plugins<LifecycleCallback>().forEach { it.onFlowReleased(inputs.matrixClient) }
                 val imageLoaderFactory = bindings<MatrixUIBindings>().notLoggedInImageLoaderFactory()
                 Coil.setImageLoader(imageLoaderFactory)
             }
@@ -132,8 +134,9 @@ class LoggedInFlowNode @AssistedInject constructor(
                         }
                     }
                 } else {
+                    val nodeLifecycleCallbacks = plugins<NodeLifecycleCallback>()
                     val inputsProvider = nodeInputsProvider(RoomFlowNode.Inputs(room))
-                    createNode<RoomFlowNode>(buildContext, plugins = listOf(inputsProvider))
+                    createNode<RoomFlowNode>(buildContext, plugins = listOf(inputsProvider) + nodeLifecycleCallbacks)
                 }
             }
             NavTarget.Settings -> {

app/src/main/kotlin/io/element/android/x/node/NodeLifecycleCallback.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.node
+
+import com.bumble.appyx.core.plugin.Plugin
+
+interface NodeLifecycleCallback : Plugin

app/src/main/kotlin/io/element/android/x/node/RoomFlowNode.kt

@@ -24,17 +24,15 @@ import com.bumble.appyx.core.lifecycle.subscribe
 import com.bumble.appyx.core.modality.BuildContext
 import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
 import com.bumble.appyx.navmodel.backstack.BackStack
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
-import io.element.android.x.di.RoomComponent
 import io.element.android.features.messages.api.MessagesEntryPoint
 import io.element.android.libraries.architecture.BackstackNode
 import io.element.android.libraries.architecture.NodeInputs
-import io.element.android.libraries.architecture.bindings
 import io.element.android.libraries.architecture.nodeInputs
-import io.element.android.libraries.di.DaggerComponentOwner
 import io.element.android.libraries.di.SessionScope
 import io.element.android.libraries.matrix.room.MatrixRoom
 import kotlinx.parcelize.Parcelize
@@ -52,7 +50,12 @@ class RoomFlowNode @AssistedInject constructor(
     ),
     buildContext = buildContext,
     plugins = plugins,
-), DaggerComponentOwner {
+) {
+
+    interface LifecycleCallback : NodeLifecycleCallback {
+        fun onFlowCreated(room: MatrixRoom) = Unit
+        fun onFlowReleased(room: MatrixRoom) = Unit
+    }
 
     data class Inputs(
         val room: MatrixRoom,
@@ -60,14 +63,16 @@ class RoomFlowNode @AssistedInject constructor(
 
     private val inputs: Inputs by nodeInputs()
 
-    override val daggerComponent: Any by lazy {
-        parent!!.bindings<RoomComponent.ParentBindings>().roomComponentBuilder().room(inputs.room).build()
-    }
-
     init {
         lifecycle.subscribe(
-            onCreate = { Timber.v("OnCreate") },
+            onCreate = {
-            onDestroy = { Timber.v("OnDestroy") }
+                Timber.v("OnCreate")
+                plugins<LifecycleCallback>().forEach { it.onFlowCreated(inputs.room) }
+            },
+            onDestroy = {
+                Timber.v("OnDestroy")
+                plugins<LifecycleCallback>().forEach { it.onFlowReleased(inputs.room) }
+            }
         )
     }
 

app/src/main/kotlin/io/element/android/x/node/RootFlowNode.kt

@@ -16,7 +16,6 @@
 
 package io.element.android.x.node
 
-import android.content.Context
 import android.os.Parcelable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
@@ -29,6 +28,7 @@ import com.bumble.appyx.core.modality.BuildContext
 import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.node.node
 import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
 import com.bumble.appyx.navmodel.backstack.BackStack
 import com.bumble.appyx.navmodel.backstack.operation.newRoot
 import com.bumble.appyx.navmodel.backstack.operation.pop
@@ -36,7 +36,6 @@ import com.bumble.appyx.navmodel.backstack.operation.push
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
-import io.element.android.x.root.MatrixClientsHolder
 import io.element.android.features.rageshake.bugreport.BugReportEntryPoint
 import io.element.android.libraries.architecture.BackstackNode
 import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
@@ -44,10 +43,9 @@ import io.element.android.libraries.architecture.createNode
 import io.element.android.libraries.architecture.nodeInputsProvider
 import io.element.android.libraries.designsystem.theme.components.CircularProgressIndicator
 import io.element.android.libraries.di.AppScope
-import io.element.android.libraries.di.ApplicationContext
-import io.element.android.libraries.di.DaggerComponentOwner
 import io.element.android.libraries.matrix.auth.MatrixAuthenticationService
 import io.element.android.libraries.matrix.core.SessionId
+import io.element.android.x.root.MatrixClientsHolder
 import io.element.android.x.root.RootPresenter
 import io.element.android.x.root.RootView
 import kotlinx.coroutines.flow.distinctUntilChanged
@@ -60,7 +58,6 @@ import timber.log.Timber
 class RootFlowNode @AssistedInject constructor(
     @Assisted buildContext: BuildContext,
     @Assisted plugins: List<Plugin>,
-    @ApplicationContext context: Context,
     private val authenticationService: MatrixAuthenticationService,
     private val matrixClientsHolder: MatrixClientsHolder,
     private val presenter: RootPresenter,
@@ -73,9 +70,7 @@ class RootFlowNode @AssistedInject constructor(
         ),
         buildContext = buildContext,
         plugins = plugins
-    ),
+    ) {
-
-    DaggerComponentOwner by (context as DaggerComponentOwner) {
 
     override fun onBuilt() {
         super.onBuilt()
@@ -178,7 +173,8 @@ class RootFlowNode @AssistedInject constructor(
                         backstack.push(NavTarget.BugReport)
                     }
                 }
-                createNode<LoggedInFlowNode>(buildContext, plugins = listOf(inputsProvider, callback))
+                val nodeLifecycleCallbacks = plugins<NodeLifecycleCallback>()
+                createNode<LoggedInFlowNode>(buildContext, plugins = listOf(inputsProvider, callback) + nodeLifecycleCallbacks)
             }
             NavTarget.NotLoggedInFlow -> createNode<NotLoggedInFlowNode>(buildContext)
             NavTarget.SplashScreen -> splashNode(buildContext)

settings.gradle.kts

@@ -65,3 +65,4 @@ include(":libraries:androidutils")
 include(":samples:minimal")
 include(":features:messages:api")
 include(":features:messages:impl")
+include(":appnav")