Remove LayoutViewFactory + refactor FeatureView to make it compose-first.

.buildscript/upload_archives.sh

@@ -9,7 +9,6 @@ GRADLE_ARGS="-P$TARGET"
 ./gradlew :formula:build $GRADLE_ARGS
 ./gradlew :formula-android:build $GRADLE_ARGS
 ./gradlew :formula-test:build $GRADLE_ARGS
-./gradlew :formula-android-compose:build $GRADLE_ARGS
 ./gradlew :formula-lint:build $GRADLE_ARGS
 ./gradlew :formula-rxjava3:build $GRADLE_ARGS
 

.github/workflows/build-workflow.yml

@@ -146,7 +146,6 @@ jobs:
         run: |
           ./gradlew :formula:build
           ./gradlew :formula-android:build
-          ./gradlew :formula-test:build 
-          ./gradlew :formula-android-compose:build 
+          ./gradlew :formula-test:build
           ./gradlew :formula-lint:build
           ./gradlew publishToMavenLocal --no-parallel --no-daemon

.github/workflows/publish.yml

@@ -52,9 +52,6 @@ jobs:
       - name: Build formula-test module
         run: ./gradlew :formula-test:build $GRADLE_ARGS
 
-      - name: Build formula-android-compose module
-        run: ./gradlew :formula-android-compose:build $GRADLE_ARGS
-
       - name: Build formula-lint module
         run: ./gradlew :formula-lint:build $GRADLE_ARGS
 

AGENTS.md

@@ -3,8 +3,7 @@
 ## Project Structure
 
 - `formula/` - Core framework (state management, actions, formulas)
-- `formula-android/` - Android integration (fragments, activities, views)
-- `formula-android-compose/` - Jetpack Compose integration
+- `formula-android/` - Android integration (fragments, activities, views, Jetpack Compose)
 - `formula-android-tests/` - Android tests
 - `formula-test/` - Testing utilities and test formulas
 - `formula-rxjava3/` - RxJava3 interop

docs/Formula-Android.md

@@ -45,14 +45,11 @@ class CounterFeatureFactory : FeatureFactory<Any, CounterKey>() {
     }
 }
 
-// View factory which uses XML layout resource.
-class CounterViewFactory : LayoutViewFactory<CounterOutput>(R.layout.counter) {
-    override fun ViewInstance.create(): FeatureView<CounterOutput> {
-        // We use [ViewInstance.view] to access the inflated view
-        val counterView = CounterRenderView(view)
-
-        // We create a [FeatureView] by passing a [RenderView]
-        return featureView(counterView)
+// View factory that renders the output with Jetpack Compose.
+class CounterViewFactory : ComposeViewFactory<CounterOutput>() {
+    @Composable
+    override fun Content(model: CounterOutput) {
+        CounterScreen(model)
     }
 }
 ```

formula-android-tests/src/test/java/com/instacart/formula/FormulaFragmentTest.kt

@@ -324,16 +324,6 @@ class FormulaFragmentTest {
         assertVisibleContract(TestKey())
     }
 
-    @Test fun `notify fragment environment if setOutput throws an error`() {
-        val key = TestKeyWithId(1)
-        navigateToTaskDetail(id = key.id)
-
-        sendStateUpdate(key, "crash")
-        assertThat(renderCalls).isNotEmpty()
-
-        assertThat(errors).hasSize(1)
-    }
-
     @Test
     fun toStringContainsTagAndKey() {
         val fragment = FormulaFragment.newInstance(TestKey())
@@ -380,6 +370,12 @@ class FormulaFragmentTest {
     private fun sendStateUpdate(contract: RouteKey, update: Any) {
         val flow = getOrCreateFlow(contract)
         flow.tryEmit(update)
+        // Drain the Compose recomposer so assertions observe a settled state.
+        // Skipped when called from a background thread; in that case the caller
+        // is responsible for idling the main looper after synchronization.
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            Shadows.shadowOf(Looper.getMainLooper()).idle()
+        }
     }
 
     private fun stateProvider(contract: RouteKey): (CoroutineScope) -> StateFlow<Any> = {

formula-android-tests/src/test/java/com/instacart/formula/TestFeatureFactory.kt

@@ -13,7 +13,7 @@ class TestFeatureFactory<Key : RouteKey>(
 ) : FeatureFactory<Unit, Key>() {
     override fun Params.initialize(): Feature {
         return Feature(
-            viewFactory = TestViewFactory { _, value ->
+            viewFactory = TestViewFactory { value ->
                 render(key, value)
             }
         ) {

formula-android/build.gradle.kts

@@ -1,5 +1,3 @@
-import org.jetbrains.dokka.gradle.DokkaTask
-
 plugins {
     id("com.android.library")
     id("kotlin-android")
@@ -14,6 +12,14 @@ apply {
 android {
     namespace = "com.instacart.formula.android"
 
+    buildFeatures {
+        compose = true
+    }
+
+    composeOptions {
+        kotlinCompilerExtensionVersion = libs.versions.compose.compiler.get()
+    }
+
     testOptions {
         unitTests.isReturnDefaultValues = true
         unitTests.isIncludeAndroidResources = true
@@ -29,6 +35,7 @@ dependencies {
     implementation(libs.androidx.annotation)
     implementation(libs.androidx.appcompat)
     implementation(libs.lifecycle.runtime.ktx)
+    api(libs.compose.ui)
 
     testImplementation(libs.androidx.test.rules)
     testImplementation(libs.androidx.test.runner)

formula-android/src/main/java/com/instacart/formula/android/ComposeViewFactory.kt

@@ -0,0 +1,26 @@
+package com.instacart.formula.android
+
+import androidx.compose.runtime.Composable
+
+/**
+ * [ViewFactory] subtype for Compose-rendered routes. Subclasses implement
+ * [Content] to render the route's render model, and may optionally override
+ * [initialModel] to supply a model rendered before the first state emission.
+ *
+ * ```
+ * class MyViewFactory : ComposeViewFactory<MyRenderModel>() {
+ *     @Composable
+ *     override fun Content(model: MyRenderModel) {
+ *         MyScreen(model)
+ *     }
+ * }
+ * ```
+ */
+abstract class ComposeViewFactory<RenderModel : Any> : ViewFactory<RenderModel> {
+
+    @Composable
+    abstract fun Content(model: RenderModel)
+
+    /** Optional initial model rendered before the first state emission. Defaults to null. */
+    open fun initialModel(): RenderModel? = null
+}

formula-android/src/main/java/com/instacart/formula/android/FeatureFactory.kt

@@ -16,10 +16,12 @@ package com.instacart.formula.android
  *     // Note: we could create our own internal dagger component here using the dependencies.
  *     val formula = TaskListFormula(dependencies.taskRepo())
  *     return Feature(
- *       viewFactory = ViewFactory.fromLayout(R.layout.task_list) { view ->
- *         val renderView = TaskListRenderView(view)
- *         featureView(renderView)
- *       }
+ *       viewFactory = object : ComposeViewFactory<TaskListRenderModel>() {
+ *           @Composable
+ *           override fun Content(model: TaskListRenderModel) {
+ *               TaskListScreen(model)
+ *           }
+ *       },
  *     ) {
  *       formula.runAsStateFlow(it, dependencies.taskListInput())
  *     }

formula-android/src/main/java/com/instacart/formula/android/FormulaFragment.kt

@@ -4,6 +4,10 @@ import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.platform.ViewCompositionStrategy
 import androidx.fragment.app.Fragment
 import com.instacart.formula.android.internal.getOrSetArguments
 import java.lang.Exception
@@ -22,7 +26,7 @@ class FormulaFragment : Fragment() {
     }
 
     private val key: RouteKey by lazy(LazyThreadSafetyMode.NONE) {
-        requireArguments().getParcelable<RouteKey>(ARG_CONTRACT)!!
+        requireArguments().getParcelable(ARG_CONTRACT)!!
     }
 
     private val formulaRouteId: RouteId<*> by lazy {
@@ -37,47 +41,34 @@ class FormulaFragment : Fragment() {
     private val routeDelegate: RouteEnvironment.RouteDelegate
         get() = environment.routeDelegate
 
-    private var featureView: FeatureView<Any>? = null
-    private var output: Any? = null
+    private val outputState: MutableState<Any?> = mutableStateOf(null)
 
     override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
-        val viewFactory = navigationStore.getViewFactory(formulaRouteId) ?: run {
-            // No view factory, no view
-            return null
+        val viewFactory = navigationStore.getViewFactory(formulaRouteId) ?: return null
+        val initial: Any? = when (viewFactory) {
+            is ComposeViewFactory -> viewFactory.initialModel()
+        }
+        return ComposeView(requireContext()).apply {
+            // Based-on: https://developer.android.com/develop/ui/compose/migrate/interoperability-apis/compose-in-views#compose-in-fragments
+            setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
+            setContent {
+                val output = outputState.value ?: initial
+                if (output != null) {
+                    routeDelegate.Content(formulaRouteId, viewFactory, output)
+                }
+            }
         }
-        val params = ViewFactory.Params(
-            context = requireContext(),
-            inflater = inflater,
-            container = container,
-        )
-
-        val featureView = environment.routeDelegate.createView(
-            routeId = formulaRouteId,
-            viewFactory = viewFactory,
-            params = params,
-        )
-        this.featureView = featureView
-        return featureView.view
-    }
-
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        super.onViewCreated(view, savedInstanceState)
-        tryToSetState()
-    }
-
-    override fun onDestroyView() {
-        super.onDestroyView()
-        featureView = null
     }
 
     fun setState(state: Any) {
-        output = state
-        tryToSetState()
+        try {
+            routeDelegate.setOutput(formulaRouteId, state) { outputState.value = it }
+        } catch (exception: Exception) {
+            environment.onScreenError(key, exception)
+        }
     }
 
-    fun currentState(): Any? {
-        return output
-    }
+    fun currentState(): Any? = outputState.value
 
     fun getRouteKey(): RouteKey {
         return key
@@ -86,15 +77,4 @@ class FormulaFragment : Fragment() {
     override fun toString(): String {
         return "${key.tag} -> $key"
     }
-
-    private fun tryToSetState() {
-        val output = output ?: return
-        val view = featureView ?: return
-
-        try {
-            routeDelegate.setOutput(formulaRouteId, output, view.setOutput)
-        } catch (exception: Exception) {
-            environment.onScreenError(key, exception)
-        }
-    }
 }