DI: rework how components are created and provided

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

@@ -34,8 +34,8 @@ import com.bumble.appyx.core.integrationpoint.NodeComponentActivity
 import com.bumble.appyx.core.plugin.NodeReadyObserver
 import io.element.android.libraries.architecture.bindings
 import io.element.android.libraries.core.log.logger.LoggerTag
-import io.element.android.libraries.theme.ElementTheme
 import io.element.android.libraries.designsystem.utils.LocalSnackbarDispatcher
+import io.element.android.libraries.theme.ElementTheme
 import io.element.android.x.di.AppBindings
 import io.element.android.x.intent.SafeUriHandler
 import timber.log.Timber
@@ -74,7 +74,6 @@ class MainActivity : NodeComponentActivity() {
                     NodeHost(integrationPoint = appyxIntegrationPoint) {
                         MainNode(
                             it,
-                            appBindings.mainDaggerComponentOwner(),
                             plugins = listOf(
                                 object : NodeReadyObserver<MainNode> {
                                     override fun init(node: MainNode) {
@@ -83,7 +82,8 @@ class MainActivity : NodeComponentActivity() {
                                         mainNode.handleIntent(intent)
                                     }
                                 }
-                            )
+                            ),
+                            context = applicationContext
                         )
                     }
                 }

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

@@ -16,6 +16,7 @@
 
 package io.element.android.x
 
+import android.content.Context
 import android.content.Intent
 import android.os.Parcelable
 import androidx.compose.runtime.Composable
@@ -27,24 +28,17 @@ import com.bumble.appyx.core.navigation.model.permanent.PermanentNavModel
 import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.node.ParentNode
 import com.bumble.appyx.core.plugin.Plugin
-import io.element.android.appnav.LoggedInAppScopeFlowNode
 import io.element.android.appnav.RootFlowNode
-import io.element.android.appnav.room.RoomLoadedFlowNode
-import io.element.android.libraries.architecture.bindings
 import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.ApplicationContext
 import io.element.android.libraries.di.DaggerComponentOwner
-import io.element.android.libraries.matrix.api.MatrixClient
-import io.element.android.libraries.matrix.api.room.MatrixRoom
-import io.element.android.x.di.MainDaggerComponentsOwner
-import io.element.android.x.di.RoomComponent
-import io.element.android.x.di.SessionComponent
 import kotlinx.coroutines.launch
 import kotlinx.parcelize.Parcelize
 
 class MainNode(
     buildContext: BuildContext,
-    private val mainDaggerComponentOwner: MainDaggerComponentsOwner,
     plugins: List<Plugin>,
+    @ApplicationContext context: Context,
 ) : ParentNode<MainNode.RootNavTarget>(
     navModel = PermanentNavModel(
         navTargets = setOf(RootNavTarget),
@@ -53,38 +47,12 @@ class MainNode(
     buildContext = buildContext,
     plugins = plugins,
 ),
-    DaggerComponentOwner by mainDaggerComponentOwner {
+    DaggerComponentOwner {
 
-    private val loggedInFlowNodeCallback = object : LoggedInAppScopeFlowNode.LifecycleCallback {
-        override fun onFlowCreated(identifier: String, client: MatrixClient) {
-            val component = bindings<SessionComponent.ParentBindings>().sessionComponentBuilder().client(client).build()
-            mainDaggerComponentOwner.addComponent(identifier, component)
-        }
-
-        override fun onFlowReleased(identifier: String, client: MatrixClient) {
-            mainDaggerComponentOwner.removeComponent(identifier)
-        }
-    }
-
-    private val roomFlowNodeCallback = object : RoomLoadedFlowNode.LifecycleCallback {
-        override fun onFlowCreated(identifier: String, room: MatrixRoom) {
-            val component = bindings<RoomComponent.ParentBindings>().roomComponentBuilder().room(room).build()
-            mainDaggerComponentOwner.addComponent(identifier, component)
-        }
-
-        override fun onFlowReleased(identifier: String, room: MatrixRoom) {
-            mainDaggerComponentOwner.removeComponent(identifier)
-        }
-    }
+    override val daggerComponent = (context as DaggerComponentOwner).daggerComponent
 
     override fun resolve(navTarget: RootNavTarget, buildContext: BuildContext): Node {
-        return createNode<RootFlowNode>(
-            context = buildContext,
-            plugins = listOf(
-                loggedInFlowNodeCallback,
-                roomFlowNodeCallback,
-            )
-        )
+        return createNode<RootFlowNode>(context = buildContext)
     }
 
     @Composable
@@ -100,4 +68,5 @@ class MainNode(
 
     @Parcelize
     object RootNavTarget : Parcelable
+
 }

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

@@ -24,7 +24,6 @@ import io.element.android.libraries.matrix.api.tracing.TracingService
 
 @ContributesTo(AppScope::class)
 interface AppBindings {
-    fun mainDaggerComponentOwner(): MainDaggerComponentsOwner
     fun snackbarDispatcher(): SnackbarDispatcher
     fun tracingService(): TracingService
     fun bugReporter(): BugReporter

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

@@ -0,0 +1,33 @@
+/*
+ * 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 com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.appnav.di.RoomComponentFactory
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.room.MatrixRoom
+import javax.inject.Inject
+
+@ContributesBinding(SessionScope::class)
+class DefaultRoomComponentFactory @Inject constructor(
+    private val roomComponentBuilder: RoomComponent.Builder
+) : RoomComponentFactory {
+
+    override fun create(room: MatrixRoom): Any {
+        return roomComponentBuilder.room(room).build()
+    }
+}

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

@@ -0,0 +1,33 @@
+/*
+ * 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 com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.appnav.di.SessionComponentFactory
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.matrix.api.MatrixClient
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultSessionComponentFactory @Inject constructor(
+    private val sessionComponentBuilder: SessionComponent.Builder
+) : SessionComponentFactory {
+
+    override fun create(client: MatrixClient): Any {
+        return sessionComponentBuilder.client(client).build()
+    }
+}

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

@@ -1,47 +0,0 @@
-/*
- * 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 MainDaggerComponentsOwner @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)
-    }
-
-    /**
-     * We expose the dagger components in the opposite order they arrived.
-     * So we pick the most recent component when searching with the [io.element.android.libraries.architecture.bindings] methods.
-     */
-    override val daggerComponent: Any
-        get() = daggerComponents.values.reversed()
-}