Does Circuit supports dynamic feature navigation?

[shaharKeisarApps]

Does Circuit support dynamic feature navigation?
Navigate with feature modules

[ZacSweers]

We haven't tried anything with it as we don't use it at slack, but it seems doable? We wouldn't use a fragment vs just using the install monitor ourselves and then calling navigate from there. The main technical hurdle I think would be getting the downloaded screens into your local circuirconfig, or you could build a custom factory that knows how to speak to downloaded ones

[shaharKeisarApps]

I am considering your development for an existing application with millions of users, which is undergoing a major architecture change soon, so I am trying to understand the limitations of the product.
thanks a lot for the answer!

[JohnBuhanan]

If we use this library for dynamic feature modules: https://github.com/cashapp/better-dynamic-features

Then it would install/uninstall dynamic feature modules and it could look like this:

// Code in :app
// Assume our "CircuitFeature" needs to contribute presenters/factories
public interface CircuitFeature : DynamicApi {
    public fun presenterFactories(): Set<Presenter.Factory>
    public fun viewFactories(): Set<Ui.Factory>
}

// MainActivity.kt
setContent {
    val installHelper = rememberSplitInstallHelper()

    val features by remember {
        // as modules are installed they will be emitted as part of this flow.
        installHelper.splitInstallManager.dynamicImplementations<CircuitFeature>()
    }.collectAsState(initial = emptyList())

    val isSplitInstalling by installHelper.isInstalling.collectAsState(initial = false)

    val allPresenterFactories: List<Presenter.Factory> =
        features.flatMap { it.presenterFactories() }

    val allViewFactories: List<Ui.Factory> = features.flatMap { it.viewFactories() }

    val circuit = Circuit.Builder()
        .apply {
            for (factory in allPresenterFactories) {
                addPresenterFactory(factory)
            }
            for (factory in allViewFactories) {
                addUiFactory(factory)
            }
        }
        .build()

    val backStack = rememberSaveableBackStack(LoginScreen)
    val navigator = rememberCircuitNavigator(backStack)

    CircuitCompositionLocals(circuit) {
        NavigableCircuitContent(navigator, backStack)
    }
}

The biggest obstacle I see is how do we do dependency injection for this scheme? I don't want to lose all the nice things @CircuitInject does lol.

Edit: Oh wait, would that land on the LoginScreen every time you installed a DFM? hmmmm... I think remember protects that right?

[JohnBuhanan]

I got a rough scheme working. Hilt CodeGen didn't seem useful for it, but Anvil CodeGen was nice to use. Any other suggestions?

// :app
interface CircuitFeature : DynamicApi {
    fun presenterFactories(): Set<Presenter.Factory>
    fun uiFactories(): Set<Ui.Factory>
    fun injectFeature()
}

// :app
@Composable
fun ShowSpotify(
    modifier: Modifier = Modifier,
) {
    val installHelper = rememberSplitInstallHelper()
  
    val features by remember {
        installHelper.splitInstallManager.dynamicImplementations<CircuitFeature>()
    }.collectAsState(initial = emptyList())
  
    val isSplitInstalling by installHelper.isInstalling.collectAsState(initial = false)
  
    val circuit = Circuit.Builder()
        .apply {
            features.forEach {
                it.injectFeature()
  
                for (factory in it.presenterFactories()) {
                    addPresenterFactory(factory)
                }
                for (factory in it.uiFactories()) {
                    addUiFactory(factory)
                }
            }
        }
        .build()
  
    val backStack = rememberSaveableBackStack(PremiumScreen)
    val navigator = rememberCircuitNavigator(backStack)
  
    CircuitCompositionLocals(circuit) {
        NavigableCircuitContent(navigator, backStack)
    }
}

// :premium
@SingleIn(FeatureScope::class)
@MergeComponent(
    scope = FeatureScope::class,
//    dependencies = [AppComponent::class],
)
interface PremiumComponent {
    fun inject(premiumFeature: PremiumFeature)

    @Component.Factory
    interface Factory {
        fun create(
//            appComponent: AppComponent 
        ): PremiumComponent
    }
}

// :premium
// Perhaps custom Anvil compiler or augment Circuit CodeGen for generating this in the future?
@Module
@ContributesTo(FeatureScope::class)
interface PremiumModule {
    @Multibinds
    fun presenterFactories(): Set<Presenter.Factory>

    @Multibinds
    fun viewFactories(): Set<Ui.Factory>
}

// :premium
@DynamicApi
class PremiumFeature : CircuitFeature {
    // Circuit CodeGen with Anvil will "contribute" these factories to DaggerPremiumComponent with some basic setup.
    @Inject
    lateinit var presenterFactories: @JvmSuppressWildcards Set<Presenter.Factory>,

    @Inject
    lateinit var uiFactories: @JvmSuppressWildcards Set<Ui.Factory>,

    override fun presenterFactories(): Set<Presenter.Factory> {
        return presenterFactories
    }

    override fun uiFactories(): Set<Ui.Factory> {
        return uiFactories
    }

    override fun inject() {
        DaggerPremiumComponent
        .factory()
        .create(
// I don't have appComponent coming in yet.
//            (applicationContext as SongifyApplication).appComponent
        )
        .inject(this)
    }
}