Inheritance in custom ComponentContext since 3.0.0-alpha09 and childFactory

[malliaridis]

With the changes of 3.0.0-alpha09 it is posisble to remove all the custom extension functions for child contexts written for custom component contexts. However, one of the limitations I faced during the upgrade was in the inheritance behavior.

The scenario
I am using an AppComponentContext for all my components, replacing the default ComponentContext and expanding it with custom variables used in all components.

In addition I have an AccessComponentContext that extends AppComponentContext and adds user access related information to the context. This looks as follows:

interface AppComponentContext : GenericComponentContext<AppComponentContext> {
  // additional context data
}

interface AccessComponentContext : AppComponentContext {
  val accessLevel: AccessLevel
}

Now, when I want to create a ChildStack from an AccessComponentContext component, I need to use AppComponentContext for the childFactory like below:

class UserAccessComponent(
    componentContext: AccessComponentContext,
    // ...
) {
    //...
    
    private val stack = childStack(
        source = navigation,
        serializer = Configuration.serializer(),
        initialStack = { listOf(Configuration.Home) },
        handleBackButton = true,
        childFactory = ::createChild,
    )

    override val childStack: Value<ChildStack<*, Child>> = stack

    private fun createChild(
        configuration: Configuration,
        componentContext: AppComponentContext, // <-- before it was AccessComponentContext
    ): Child {
        // all the child components use AccessComponentContext, so this had to be added:
        require(componentContext is AccessComponentContext) 

        return when (configuration) {
            // ...
        }
    }

Is there a better way to handle this kind of abstraction without adding custom extension functions again?

To solve this in a different way I was thinking of something like generics in the custom ComponentContext or not using inheritance at all in custom components contexts, but I am not sure if that will improve the overall code. This however would require different implementation in order to be able to switch between two or more contexts.

[arkivanov]

Thanks for the feedback!

Can you try something as follows?

interface BaseComponentContext<out T : Any> : GenericComponentContext<T> {
  // additional context data
}

interface AppComponentContext : BaseComponentContext<AppComponentContext>

interface AccessComponentContext : BaseComponentContext<AccessComponentContext> {
  val accessLevel: AccessLevel
}

[malliaridis]

That's what I was trying to achieve but took AppComponentContext as the base and ended up with more code changes than intended because I didn't add the additional interface. That solves precisely my issue. Thanks 👍

Edit: This solves the issue described, but requires the use of BaseComponentContext when trying to create an AppComponentContext child from an AccessComponentContext using childContext(), leading to a similar limitation just in another place.

[arkivanov]

Yeah, in this case it requires some more code.

interface AppComponentContextDependencies {
    val thing: String
}

interface AppComponentContext : GenericComponentContext<AppComponentContext>, AppComponentContextDependencies

class DefaultAppComponentContext(
    delegate: GenericComponentContext<*>,
    override val thing: String,
) : AppComponentContext,
    LifecycleOwner by delegate,
    StateKeeperOwner by delegate,
    InstanceKeeperOwner by delegate,
    BackHandlerOwner by delegate {

    override val componentContextFactory: ComponentContextFactory<AppComponentContext> =
        ComponentContextFactory { lifecycle, stateKeeper, instanceKeeper, backHandler ->
            DefaultAppComponentContext(
                delegate = DefaultComponentContext(lifecycle, stateKeeper, instanceKeeper, backHandler),
                thing = thing,
            )
        }
}


enum class AccessLevel

interface AccessComponentContextDependencies : AppComponentContextDependencies {
    val accessLevel: AccessLevel
}

interface AccessComponentContext : GenericComponentContext<AccessComponentContext>, AccessComponentContextDependencies

class DefaultAccessComponentContext(
    delegate: AppComponentContext,
    override val accessLevel: AccessLevel,
) : AccessComponentContext,
    LifecycleOwner by delegate,
    StateKeeperOwner by delegate,
    InstanceKeeperOwner by delegate,
    BackHandlerOwner by delegate,
    AppComponentContextDependencies by delegate {

    override val componentContextFactory: ComponentContextFactory<AccessComponentContext> =
        ComponentContextFactory { lifecycle, stateKeeper, instanceKeeper, backHandler ->
            DefaultAccessComponentContext(
                delegate = delegate.componentContextFactory(lifecycle, stateKeeper, instanceKeeper, backHandler),
                accessLevel = accessLevel,
            )
        }
}


fun AccessComponentContext.asAppComponentContext(): AppComponentContext =
    DefaultAppComponentContext(
        delegate = this,
        thing = thing,
    )

[arkivanov]

However, I would consider to stick with just AppComponentContext and pass the rest (e.g. accessLevel) via constructor to every component that requires that.

[malliaridis]

Both solutions are addressing the issue, but as you mentioned, sticking with one custom context and injecting the rest seems the cleanest way to do this. Thanks for the multiple solutions. 😊