Compose Runtime Integration Take 2

benchmarks/performance-poetry/complex-poetry/build.gradle.kts

@@ -2,6 +2,7 @@ plugins {
   id("com.android.application")
   `kotlin-android`
   id("kotlin-parcelize")
+  id("app.cash.molecule")
 }
 android {
   compileSdk = 32

benchmarks/performance-poetry/complex-poetry/src/main/java/com/squareup/benchmarks/performance/complex/poetry/MaybeLoadingGatekeeperWorkflow.kt

@@ -1,5 +1,6 @@
 package com.squareup.benchmarks.performance.complex.poetry
 
+import androidx.compose.runtime.Composable
 import com.squareup.benchmarks.performance.complex.poetry.instrumentation.ActionHandlingTracingInterceptor
 import com.squareup.benchmarks.performance.complex.poetry.instrumentation.asTraceableWorker
 import com.squareup.benchmarks.performance.complex.poetry.views.LoaderSpinner
@@ -48,5 +49,36 @@ class MaybeLoadingGatekeeperWorkflow<T : Any>(
     )
   }
 
+  @Composable
+  override fun Rendering(
+    renderProps: Unit,
+    renderState: IsLoading,
+    context: RenderContext,
+    hoistRendering: @Composable (rendering: MayBeLoadingScreen) -> Unit
+  ) {
+    context.runningWorker(isLoading.asTraceableWorker("GatekeeperLoading")) {
+      action {
+        state = it
+      }
+    }
+    context.ChildRendering(
+      childWithLoading, childProps, "",
+      hoistRendering = {
+        hoistRendering(
+          MayBeLoadingScreen(
+            baseScreen = it,
+            loaders = if (renderState) listOf(LoaderSpinner) else emptyList()
+          )
+        )
+      }
+    ) {
+      action(ActionHandlingTracingInterceptor.keyForTrace("GatekeeperChildFinished")) {
+        setOutput(
+          Unit
+        )
+      }
+    }
+  }
+
   override fun snapshotState(state: IsLoading): Snapshot? = null
 }

benchmarks/performance-poetry/complex-poetry/src/main/java/com/squareup/benchmarks/performance/complex/poetry/PerformancePoemWorkflow.kt

@@ -1,5 +1,9 @@
 package com.squareup.benchmarks.performance.complex.poetry
 
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import com.squareup.benchmarks.performance.complex.poetry.PerformancePoemWorkflow.Action.ClearSelection
 import com.squareup.benchmarks.performance.complex.poetry.PerformancePoemWorkflow.Action.HandleStanzaListOutput
 import com.squareup.benchmarks.performance.complex.poetry.PerformancePoemWorkflow.Action.SelectNext
@@ -16,6 +20,7 @@ import com.squareup.benchmarks.performance.complex.poetry.views.BlankScreen
 import com.squareup.sample.container.overviewdetail.OverviewDetailScreen
 import com.squareup.sample.poetry.PoemWorkflow
 import com.squareup.sample.poetry.PoemWorkflow.ClosePoem
+import com.squareup.sample.poetry.StanzaListScreen
 import com.squareup.sample.poetry.StanzaListWorkflow
 import com.squareup.sample.poetry.StanzaListWorkflow.NO_SELECTED_STANZA
 import com.squareup.sample.poetry.StanzaScreen
@@ -57,6 +62,7 @@ import kotlinx.coroutines.flow.flow
  * break ties/conflicts with a token in the start/stop requests. We leave that complexity out
  * here. **
  */
+@OptIn(WorkflowUiExperimentalApi::class)
 class PerformancePoemWorkflow(
   private val simulatedPerfConfig: SimulatedPerfConfig = SimulatedPerfConfig.NO_SIMULATED_PERF,
   private val isLoading: MutableStateFlow<Boolean>,
@@ -234,6 +240,164 @@ class PerformancePoemWorkflow(
     }
   }
 
+  @Composable
+  override fun Rendering(
+    renderProps: Poem,
+    renderState: State,
+    context: RenderContext,
+    hoistRendering: @Composable (rendering: OverviewDetailScreen) -> Unit
+  ) {
+    when (renderState) {
+      Initializing -> {
+        // Again, the entire `Initializing` state is a smell, which is most obvious from the
+        // use of `Worker.from { Unit }`. A Worker doing no work and only shuttling the state
+        // along is usually the sign you have an extraneous state that can be collapsed!
+        // Don't try this at home.
+        context.runningWorker(
+          Worker.from {
+            isLoading.value = true
+          },
+          "initializing"
+        ) {
+          action {
+            isLoading.value = false
+            state = Selected(NO_SELECTED_STANZA)
+          }
+        }
+        hoistRendering(OverviewDetailScreen(overviewRendering = BackStackScreen(BlankScreen)))
+      }
+      else -> {
+        val (stanzaIndex, currentStateIsLoading, repeat) = when (renderState) {
+          is ComplexCall -> Triple(renderState.payload, true, renderState.repeater)
+          is Selected -> Triple(renderState.stanzaIndex, false, 0)
+          Initializing -> throw IllegalStateException("No longer initializing.")
+        }
+
+        if (currentStateIsLoading) {
+          if (repeat > 0) {
+            // Running a flow that emits 'repeat' number of times
+            context.runningWorker(
+              flow {
+                while (true) {
+                  // As long as this Worker is running we want to be emitting values.
+                  delay(2)
+                  emit(repeat)
+                }
+              }.asTraceableWorker("EventRepetition")
+            ) {
+              action {
+                (state as? ComplexCall)?.let { currentState ->
+                  // Still repeating the complex call
+                  state = ComplexCall(
+                    payload = currentState.payload,
+                    repeater = (currentState.repeater - 1).coerceAtLeast(0)
+                  )
+                }
+              }
+            }
+          } else {
+            context.runningWorker(
+              worker = TraceableWorker.from("PoemLoading") {
+                isLoading.value = true
+                delay(simulatedPerfConfig.complexityDelay)
+                // No Output for Worker is necessary because the selected index
+                // is already in the state.
+              }
+            ) {
+              action {
+                isLoading.value = false
+                (state as? ComplexCall)?.let { currentState ->
+                  state = Selected(currentState.payload)
+                }
+              }
+            }
+          }
+        }
+
+        val previousStanzas: MutableState<List<StanzaScreen>> = remember {
+          mutableStateOf(emptyList())
+        }
+        val visibleStanza: MutableState<StanzaScreen?> = remember {
+          mutableStateOf(null)
+        }
+
+        if (stanzaIndex != NO_SELECTED_STANZA) {
+          renderProps.stanzas.subList(0, stanzaIndex)
+            .forEachIndexed { index, _ ->
+              context.ChildRendering(
+                StanzaWorkflow,
+                Props(
+                  poem = renderProps,
+                  index = index,
+                  eventHandlerTag = ActionHandlingTracingInterceptor::keyForTrace
+                ),
+                key = "$index",
+                hoistRendering = @Composable {
+                  previousStanzas.value = previousStanzas.value + it
+                }
+              ) {
+                noAction()
+              }
+            }
+          context.ChildRendering(
+            StanzaWorkflow,
+            Props(
+              poem = renderProps,
+              index = stanzaIndex,
+              eventHandlerTag = ActionHandlingTracingInterceptor::keyForTrace
+            ),
+            key = "$stanzaIndex",
+            hoistRendering = @Composable {
+              visibleStanza.value = it
+            }
+          ) {
+            when (it) {
+              CloseStanzas -> ClearSelection(simulatedPerfConfig)
+              ShowPreviousStanza -> SelectPrevious(simulatedPerfConfig)
+              ShowNextStanza -> SelectNext(simulatedPerfConfig)
+            }
+          }
+        }
+
+        val stackedStanzas = visibleStanza.value?.let {
+          (previousStanzas.value + it).toBackStackScreen<Screen>()
+        }
+
+        val stanzaListOverview: MutableState<StanzaListScreen?> = remember {
+          mutableStateOf(null)
+        }
+        context.ChildRendering(
+          StanzaListWorkflow,
+          StanzaListWorkflow.Props(
+            poem = renderProps,
+            eventHandlerTag = ActionHandlingTracingInterceptor::keyForTrace
+          ),
+          key = "",
+          hoistRendering = @Composable {
+            stanzaListOverview.value = it.copy(selection = stanzaIndex)
+          }
+        ) { selected ->
+          HandleStanzaListOutput(simulatedPerfConfig, selected)
+        }
+
+        hoistRendering(
+          stackedStanzas
+            ?.let {
+              OverviewDetailScreen(
+                overviewRendering = BackStackScreen(stanzaListOverview.value!!),
+                detailRendering = it
+              )
+            } ?: OverviewDetailScreen(
+            overviewRendering = BackStackScreen(stanzaListOverview.value!!),
+            selectDefault = {
+              context.actionSink.send(HandleStanzaListOutput(simulatedPerfConfig, 0))
+            }
+          )
+        )
+      }
+    }
+  }
+
   override fun snapshotState(state: State): Snapshot? = null
 
   internal sealed class Action : WorkflowAction<Poem, State, ClosePoem>() {

benchmarks/performance-poetry/complex-poetry/src/main/java/com/squareup/benchmarks/performance/complex/poetry/PerformancePoemsBrowserWorkflow.kt

@@ -1,5 +1,6 @@
 package com.squareup.benchmarks.performance.complex.poetry
 
+import androidx.compose.runtime.Composable
 import com.squareup.benchmarks.performance.complex.poetry.PerformancePoemsBrowserWorkflow.State
 import com.squareup.benchmarks.performance.complex.poetry.PerformancePoemsBrowserWorkflow.State.ComplexCall
 import com.squareup.benchmarks.performance.complex.poetry.PerformancePoemsBrowserWorkflow.State.Initializing
@@ -42,6 +43,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
  * break ties/conflicts with a token in the start/stop requests. We leave that complexity out
  * here. **
  */
+@OptIn(WorkflowUiExperimentalApi::class)
 class PerformancePoemsBrowserWorkflow(
   private val simulatedPerfConfig: SimulatedPerfConfig,
   private val poemWorkflow: PoemWorkflow,
@@ -70,7 +72,6 @@ class PerformancePoemsBrowserWorkflow(
     return if (simulatedPerfConfig.useInitializingState) Initializing else NoSelection
   }
 
-  @OptIn(WorkflowUiExperimentalApi::class)
   override fun render(
     renderProps: List<Poem>,
     renderState: State,
@@ -154,6 +155,106 @@ class PerformancePoemsBrowserWorkflow(
     }
   }
 
+  @Composable
+  override fun Rendering(
+    renderProps: List<Poem>,
+    renderState: State,
+    context: RenderContext,
+    hoistRendering: @Composable (rendering: OverviewDetailScreen) -> Unit
+  ) {
+    val poemListProps = Props(
+      poems = renderProps,
+      eventHandlerTag = ActionHandlingTracingInterceptor::keyForTrace
+    )
+    context.ChildRendering(
+      child = PoemListWorkflow,
+      props = poemListProps,
+      key = "",
+      hoistRendering = { poemListRendering ->
+        when (renderState) {
+          // Again, then entire `Initializing` state is a smell, which is most obvious from the
+          // use of `Worker.from { Unit }`. A Worker doing no work and only shuttling the state
+          // along is usually the sign you have an extraneous state that can be collapsed!
+          // Don't try this at home.
+          is Initializing -> {
+            context.runningWorker(TraceableWorker.from("BrowserInitializing") { Unit }, "init") {
+            isLoading.value = true
+            action {
+              isLoading.value = false
+              state = NoSelection
+            }
+          }
+            hoistRendering(OverviewDetailScreen(overviewRendering = BackStackScreen(BlankScreen)))
+          }
+          is NoSelection -> {
+            hoistRendering(
+              OverviewDetailScreen(
+                overviewRendering = BackStackScreen(
+                  poemListRendering.copy(selection = NO_POEM_SELECTED)
+                )
+              )
+            )
+          }
+          is ComplexCall -> {
+            context.runningWorker(
+              TraceableWorker.from("ComplexCallBrowser(${renderState.payload})") {
+                isLoading.value = true
+                delay(simulatedPerfConfig.complexityDelay)
+                // No Output for Worker is necessary because the selected index
+                // is already in the state.
+              }
+            ) {
+              action {
+                isLoading.value = false
+                (state as? ComplexCall)?.let { currentState ->
+                  state = if (currentState.payload != NO_POEM_SELECTED) {
+                    Selected(currentState.payload)
+                  } else {
+                    NoSelection
+                  }
+                }
+              }
+            }
+            val poemOverview = OverviewDetailScreen(
+              overviewRendering = BackStackScreen(
+                poemListRendering.copy(selection = renderState.payload)
+              )
+            )
+            if (renderState.payload != NO_POEM_SELECTED) {
+              context.ChildRendering(
+                poemWorkflow,
+                renderProps[renderState.payload],
+                key = "",
+                hoistRendering = { poem: OverviewDetailScreen ->
+                  hoistRendering(poemOverview + poem)
+                }
+              ) { clearSelection }
+            } else {
+              hoistRendering(poemOverview)
+            }
+          }
+          is Selected -> {
+            val poemOverview = OverviewDetailScreen(
+              overviewRendering = BackStackScreen(
+                poemListRendering.copy(selection = renderState.poemIndex)
+              )
+            )
+            context.ChildRendering(
+              poemWorkflow,
+              renderProps[renderState.poemIndex],
+              key = "",
+              hoistRendering = { poem: OverviewDetailScreen ->
+                hoistRendering(poemOverview + poem)
+              }
+            ) { clearSelection }
+          }
+        }
+      }
+    ) { selected ->
+      choosePoem(selected)
+    }
+  }
+
   override fun snapshotState(state: State): Snapshot? = null
 
   private fun choosePoem(

benchmarks/performance-poetry/complex-poetry/src/main/java/com/squareup/benchmarks/performance/complex/poetry/PerformancePoetryActivity.kt

@@ -83,8 +83,12 @@ class PerformancePoetryActivity : AppCompatActivity() {
       installedInterceptor = ActionHandlingTracingInterceptor()
     }
 
-    val isFrameTimeout = intent.getBooleanExtra(EXTRA_RUNTIME_FRAME_TIMEOUT, false)
-    val runtimeConfig = if (isFrameTimeout) FrameTimeout() else RenderPerAction
+    val isFrameTimeout = true; //intent.getBooleanExtra(EXTRA_RUNTIME_FRAME_TIMEOUT, false)
+    val runtimeConfig = if (isFrameTimeout) {
+      FrameTimeout(useComposeInRuntime = true)
+    } else {
+      RenderPerAction
+    }
 
     val component =
       PerformancePoetryComponent(installedInterceptor, simulatedPerfConfig, runtimeConfig)