How to access locally scoped data from CompositionLocal in component

[leononame]

I have some Compose Multiplatform application code that connects to a SQLite database and puts that database into a CompisitionLocalProvider so that child components can access the database. Somewhere down the tree, I have a Component that should read from the database and get those results. I want to put that logic into the Component code so that I can query the database in the onCreate lifecycle callback, but I don't know how I can inject the database into the component, since there is no composable function inside the component code itself. Is there a way to instantiate a component with a composable function? Ideally in a ChildStack's childfactory function?

[arkivanov]

I think you do leverage Dependency Injection instead, pass the database class into your component via constructor.

[leononame]

Thanks for your answer. How could I achieve this when the database is not created in the MainActivity and not a global Singleton?

Currently, the database connection is created dynamically inside a Composable function and then provided through LocalCompositionProvider. I don't know how to pass the dependency to the Component constructor because a Cmponent's Constructor is called in the Child Stack's childFactory function. The only option I see is wiring the dependecy all the way up to the RootComponent, but because the database is created dynamically or even multiple handles are open for different database files at the same time, I don't really have anything I could put all the way up to the root component.

[arkivanov]

Currently, the database connection is created dynamically inside a Composable function

I might be missing context, but this doesn't look like a good approach. You can create the database one of your component and pass it down to every child component, or have one single instance in the application, depending on the use case.

[leononame]

Thanks! That makes sense, it is a bit ugly because I have to wire the dependency through quite a lot components, but I totally see your point

[arkivanov]

To avoid prop drilling (i.e. passing a dependency through all components down to the one that needs the dependency), you can leverage the "Assisted Injection" pattern. If you are using Dagger (and maybe also Anvil) then see the docs and this sample.

If you are using another DI framework, then please refer to its documentation.

If you are using manual DI (i.e. calling constructors manually), then here is a simple example.

// Interfaces

interface RootComponent {
    val stack: Value<ChildStack<*, Child>>

    sealed class Child {
        class FirstChild(val component: FirstComponent) : Child()
        class SecondChild(val component: FirstComponent) : Child()
    }

    fun interface Factory {
        operator fun invoke(
            componentContext: ComponentContext,
        ): RootComponent
    }
}

interface FirstComponent {

    fun interface Factory {
        operator fun invoke(
            componentContext: ComponentContext,
        ): FirstComponent
    }
}

interface SecondComponent {

    fun interface Factory {
        operator fun invoke(
            componentContext: ComponentContext,
        ): SecondComponent
    }
}

// Implementations

class DefaultFirstComponent private constructor(
    componentContext: ComponentContext,
) : FirstComponent, ComponentContext by componentContext {

    object Factory : FirstComponent.Factory {
        override fun invoke(componentContext: ComponentContext): FirstComponent =
            DefaultFirstComponent(componentContext)
    }
}

class DefaultSecondComponent private constructor(
    componentContext: ComponentContext,
    database: Database,
) : SecondComponent, ComponentContext by componentContext {

    class Factory(
        private val database: Database,
    ) : SecondComponent.Factory {
        override fun invoke(componentContext: ComponentContext): SecondComponent =
            DefaultSecondComponent(componentContext, database)
    }
}

class DefaultRootComponent private constructor(
    componentContext: ComponentContext,
    firstComponentFactory: FirstComponent.Factory, // Use these factories to create child components
    secondComponentFactory: SecondComponent.Factory,
) : RootComponent, ComponentContext by componentContext {

    override val stack: Value<ChildStack<*, RootComponent.Child>> = TODO()

    class Factory(
        private val firstComponentFactory: FirstComponent.Factory,
        private val secondComponentFactory: SecondComponent.Factory,
    ) : RootComponent.Factory {
        override fun invoke(componentContext: ComponentContext): RootComponent =
            DefaultRootComponent(
                componentContext,
                firstComponentFactory,
                secondComponentFactory,
            )
    }
}

class App : Application() {
    val database: Database by lazy { TODO() }
}

class RootActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val database = (application as App).database

        val root =
            DefaultRootComponent.Factory(
                firstComponentFactory = DefaultFirstComponent.Factory,
                secondComponentFactory = DefaultSecondComponent.Factory(database),
            ).invoke(
                componentContext = defaultComponentContext(),
            )

        // The rest of the code
    }
}

[leononame]

Wow, thanks for the pointer! The factory method makes sense to me. I'll consider it, though for the time being I'll keep passing the prop around as it is a bit more explicit and we don't have any DI framework in use yet. Thanks for your incredible help, I'll have a closer look at Dagger as well