Try harder to get a frame from the recomposer on render, regardless of the underlying dispatcher.

Author: zach-klippenstein

samples/compose-samples/src/main/java/com/squareup/sample/compose/nestedrenderings/RecursiveViewFactory.kt

@@ -2,6 +2,14 @@
 
 package com.squareup.sample.compose.nestedrenderings
 
+import androidx.compose.animation.Animatable
+import androidx.compose.animation.core.FastOutLinearInEasing
+import androidx.compose.animation.core.LinearOutSlowInEasing
+import androidx.compose.animation.core.keyframes
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.PressInteraction
 import androidx.compose.foundation.layout.Arrangement.SpaceEvenly
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -13,12 +21,17 @@ import androidx.compose.material.Card
 import androidx.compose.material.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment.Companion.CenterHorizontally
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.compositeOver
+import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.tooling.preview.Preview
 import com.squareup.sample.compose.R
@@ -27,6 +40,7 @@ import com.squareup.workflow1.ui.Screen
 import com.squareup.workflow1.ui.compose.ScreenComposableFactory
 import com.squareup.workflow1.ui.compose.WorkflowRendering
 import com.squareup.workflow1.ui.compose.tooling.Preview
+import kotlin.time.DurationUnit.MILLISECONDS
 
 /**
  * Composition local of [Color] to use as the background color for a [RecursiveComposableFactory].
@@ -44,7 +58,26 @@ val RecursiveComposableFactory = ScreenComposableFactory<Rendering> { rendering
       .compositeOver(Color.Black)
   }
 
-  Card(backgroundColor = color) {
+  var lastFlashedTrigger by remember { mutableIntStateOf(rendering.flashTrigger) }
+  val flashAlpha = remember { Animatable(Color(0x00FFFFFF)) }
+
+  // Flash the card white when asked.
+  LaunchedEffect(rendering.flashTrigger) {
+    if (rendering.flashTrigger != 0) {
+      lastFlashedTrigger = rendering.flashTrigger
+      flashAlpha.animateTo(Color(0x00FFFFFF), animationSpec = keyframes {
+        Color.White at (rendering.flashTime / 7).toInt(MILLISECONDS) using FastOutLinearInEasing
+        Color(0x00FFFFFF) at rendering.flashTime.toInt(MILLISECONDS) using LinearOutSlowInEasing
+      })
+    }
+  }
+
+  Card(
+    backgroundColor = flashAlpha.value.compositeOver(color),
+    modifier = Modifier.pointerInput(rendering) {
+      detectTapGestures(onPress = { rendering.onSelfClicked() })
+    }
+  ) {
     Column(
       Modifier
         .padding(dimensionResource(R.dimen.recursive_padding))
@@ -76,10 +109,14 @@ fun RecursiveViewFactoryPreview() {
           StringRendering("foo"),
           Rendering(
             children = listOf(StringRendering("bar")),
+            flashTrigger = 0,
+            onSelfClicked = {},
             onAddChildClicked = {},
             onResetClicked = {}
           )
         ),
+        flashTrigger = 0,
+        onSelfClicked = {},
         onAddChildClicked = {},
         onResetClicked = {}
       ),

samples/compose-samples/src/main/java/com/squareup/sample/compose/nestedrenderings/RecursiveWorkflow.kt

@@ -1,8 +1,13 @@
 package com.squareup.sample.compose.nestedrenderings
 
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import com.squareup.sample.compose.databinding.LegacyViewBinding
@@ -14,6 +19,12 @@ import com.squareup.workflow1.compose.renderChild
 import com.squareup.workflow1.ui.AndroidScreen
 import com.squareup.workflow1.ui.Screen
 import com.squareup.workflow1.ui.ScreenViewFactory
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.ZERO
+import kotlin.time.Duration.Companion.seconds
 
 /**
  * A simple workflow that produces [Rendering]s of zero or more children.
@@ -24,7 +35,7 @@ import com.squareup.workflow1.ui.ScreenViewFactory
  * through Composable renderings as well as adapting in both directions.
  */
 @OptIn(WorkflowExperimentalApi::class)
-object RecursiveWorkflow : ComposeWorkflow<Unit, Nothing, Screen>() {
+object RecursiveWorkflow : ComposeWorkflow<Unit, Unit, Screen>() {
 
   /**
    * A rendering from a [RecursiveWorkflow].
@@ -35,8 +46,11 @@ object RecursiveWorkflow : ComposeWorkflow<Unit, Nothing, Screen>() {
    */
   data class Rendering(
     val children: List<Screen>,
-    val onAddChildClicked: () -> Unit,
-    val onResetClicked: () -> Unit
+    val flashTrigger: Int = 0,
+    val flashTime: Duration = ZERO,
+    val onSelfClicked: () -> Unit = {},
+    val onAddChildClicked: () -> Unit = {},
+    val onResetClicked: () -> Unit = {}
   ) : Screen
 
   /**
@@ -51,16 +65,43 @@ object RecursiveWorkflow : ComposeWorkflow<Unit, Nothing, Screen>() {
     )
   }
 
+  @OptIn(ExperimentalStdlibApi::class)
   @Composable override fun produceRendering(
     props: Unit,
-    emitOutput: (Nothing) -> Unit
+    emitOutput: (Unit) -> Unit
   ): Screen {
     var children by rememberSaveable { mutableStateOf(0) }
+    var flashTrigger by remember { mutableIntStateOf(0) }
+    val coroutineScope = rememberCoroutineScope()
+
+    DisposableEffect(Unit) {
+      println("OMG coroutineScope dispatcher: ${coroutineScope.coroutineContext[CoroutineDispatcher]}")
+      onDispose {}
+    }
+
+    LaunchedEffect(Unit) {
+      println("OMG LaunchedEffect dispatcher: ${coroutineScope.coroutineContext[CoroutineDispatcher]}")
+    }
+
     return Rendering(
       children = List(children) { i ->
-        val child = renderChild(RecursiveWorkflow)
+        val child = renderChild(RecursiveWorkflow, onOutput = {
+          // When a child is clicked, cascade the flash up.
+          coroutineScope.launch {
+            delay(0.1.seconds)
+            flashTrigger++
+            emitOutput(Unit)
+          }
+        })
         if (i % 2 == 0) child else LegacyRendering(child)
       },
+      flashTrigger = flashTrigger,
+      flashTime = 0.5.seconds,
+      // Trigger a cascade of flashes when clicked.
+      onSelfClicked = {
+        flashTrigger++
+        emitOutput(Unit)
+      },
       onAddChildClicked = { children++ },
       onResetClicked = { children = 0 }
     )

workflow-runtime/src/commonMain/kotlin/com/squareup/workflow1/SimpleLoggingWorkflowInterceptor.kt

@@ -85,8 +85,8 @@ public open class SimpleLoggingWorkflowInterceptor : WorkflowInterceptor {
       props: PropsT,
       onOutput: ((OutputT) -> Unit)?
     ): RenderingT {
-      logMethod("onRenderChild", session, "workflow" to childWorkflow, "props" to props) {
-        return childRenderer.renderChild(childWorkflow, props, onOutput = { output ->
+      return logMethod("onRenderChild", session, "workflow" to childWorkflow, "props" to props) {
+         childRenderer.renderChild(childWorkflow, props, onOutput = { output ->
           logMethod("onOutput", session, "output" to output) {
             onOutput?.invoke(output)
           }

workflow-runtime/src/commonMain/kotlin/com/squareup/workflow1/internal/compose/ComposeWorkflowChildNode.kt

@@ -13,7 +13,6 @@ import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.saveable.LocalSaveableStateRegistry
 import androidx.compose.runtime.saveable.SaveableStateRegistry
 import androidx.compose.runtime.setValue
-import androidx.compose.runtime.snapshots.Snapshot
 import com.squareup.workflow1.ActionApplied
 import com.squareup.workflow1.ActionProcessingResult
 import com.squareup.workflow1.NoopWorkflowInterceptor
@@ -32,6 +31,7 @@ import com.squareup.workflow1.compose.WorkflowComposableRenderer
 import com.squareup.workflow1.identifier
 import com.squareup.workflow1.internal.IdCounter
 import com.squareup.workflow1.internal.WorkflowNodeId
+import com.squareup.workflow1.internal.compose.coroutines.requireSend
 import com.squareup.workflow1.internal.createId
 import com.squareup.workflow1.workflowSessionToString
 import kotlinx.coroutines.CoroutineName
@@ -42,6 +42,11 @@ import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.selects.SelectBuilder
 import kotlin.coroutines.CoroutineContext
 
+private const val OUTPUT_QUEUE_LIMIT = 1_000
+
+/**
+ * Representation and implementation of a single [ComposeWorkflow].
+ */
 @OptIn(WorkflowExperimentalApi::class)
 internal class ComposeWorkflowChildNode<PropsT, OutputT, RenderingT>(
   override val id: WorkflowNodeId,
@@ -74,7 +79,7 @@ internal class ComposeWorkflowChildNode<PropsT, OutputT, RenderingT>(
   private var lastProps by mutableStateOf(initialProps)
   private val saveableStateRegistry: SaveableStateRegistry
   private var snapshotCache = snapshot?.childTreeSnapshots
-  private val nodesToSnapshot = mutableVectorOf<ComposeChildNode<*, *, *>>()
+  private val childNodes = mutableVectorOf<ComposeChildNode<*, *, *>>()
 
   private val outputsChannel = Channel<OutputT>(capacity = OUTPUT_QUEUE_LIMIT)
 
@@ -94,11 +99,7 @@ internal class ComposeWorkflowChildNode<PropsT, OutputT, RenderingT>(
    * Function invoked when [onNextAction] receives an output from [outputsChannel].
    */
   private val processOutputFromChannel: (OutputT) -> ActionProcessingResult = { output ->
-    // Ensure any state updates performed by the output sender gets to invalidate any
-    // compositions that read them, so we can check hasInvalidations below.
-    // If no frame has been requested yet this will request a frame. If the dispatcher is
-    // Main.immediate the frame will be requested synchronously.
-    Snapshot.sendApplyNotifications()
+    log("got output from channel: $output")
 
     val applied = ActionApplied(
       output = WorkflowOutput(output),
@@ -109,11 +110,15 @@ internal class ComposeWorkflowChildNode<PropsT, OutputT, RenderingT>(
     )
 
     // Invoke the parent's handler to propagate the output up the workflow tree.
-    emitAppliedActionToParent(applied)
+    log("sending output to parent: $applied")
+    emitAppliedActionToParent(applied).also {
+      log("finished sending output to parent, result was: $it")
+    }
   }
 
   init {
     interceptor.onSessionStarted(workflowScope = this, session = this)
+
     val workflowSnapshot = snapshot?.workflowSnapshot
     var restoredRegistry: SaveableStateRegistry? = null
     // Don't care about this return value, our state is separate.
@@ -140,6 +145,9 @@ internal class ComposeWorkflowChildNode<PropsT, OutputT, RenderingT>(
     workflow: Workflow<PropsT, OutputT, RenderingT>,
     props: PropsT
   ): RenderingT {
+    // No need to key anything on `this`, since either this is at the root of the composition, or
+    // inside a renderChild call and renderChild does the keying.
+    log("rendering workflow: props=$props")
     workflow as ComposeWorkflow
     return withCompositionLocals(
       LocalSaveableStateRegistry provides saveableStateRegistry,
@@ -217,7 +225,13 @@ internal class ComposeWorkflowChildNode<PropsT, OutputT, RenderingT>(
 
   @OptIn(ExperimentalCoroutinesApi::class, DelicateCoroutinesApi::class)
   override fun onNextAction(selector: SelectBuilder<ActionProcessingResult>): Boolean {
-    val empty = outputsChannel.isEmpty || outputsChannel.isClosedForReceive
+    var empty = childNodes.fold(true) { empty, child ->
+      // Do this separately so the compiler doesn't avoid it if empty is already false.
+      val childEmpty = child.onNextAction(selector)
+      empty && childEmpty
+    }
+
+    empty = empty && (outputsChannel.isEmpty || outputsChannel.isClosedForReceive)
     with(selector) {
       outputsChannel.onReceive(processOutputFromChannel)
     }
@@ -285,15 +299,15 @@ internal class ComposeWorkflowChildNode<PropsT, OutputT, RenderingT>(
   }
 
   private fun addChildNode(childNode: ComposeChildNode<*, *, *>) {
-    nodesToSnapshot += childNode
+    childNodes += childNode
   }
 
   private fun removeChildNode(childNode: ComposeChildNode<*, *, *>) {
-    nodesToSnapshot -= childNode
+    childNodes -= childNode
   }
 
   private fun createChildSnapshots(): Map<WorkflowNodeId, TreeSnapshot> = buildMap {
-    nodesToSnapshot.forEach { child ->
+    childNodes.forEach { child ->
       put(child.id, child.snapshot())
     }
   }
@@ -318,19 +332,20 @@ internal class ComposeWorkflowChildNode<PropsT, OutputT, RenderingT>(
     appliedActionFromChild: ActionApplied<ChildOutputT>,
     onOutput: ((ChildOutputT) -> Unit)?
   ): ActionProcessingResult {
+    log("handling child output: $appliedActionFromChild")
     val outputFromChild = appliedActionFromChild.output
-    if (outputFromChild == null || onOutput == null) {
-      // The child didn't actually emit anything or we don't care, so we don't need to
-      // propagate anything to the parent. We halt the action cascade by simply returning
-      // here without calling emitAppliedActionToParent.
-      //
-      // NOTE: SubtreeManager has an additional case for PARTIAL_TREE_RENDERING, but we
-      // can just assume that using ComposeWorkflow at all implies that optimization.
-      //
-      // If our child state changed, we need to report that ours did too, as per the
-      // comment in StatefulWorkflowNode.applyAction.
-      return appliedActionFromChild.withOutput(null)
-    }
+    // if (outputFromChild == null || onOutput == null) {
+    //   // The child didn't actually emit anything or we don't care, so we don't need to
+    //   // propagate anything to the parent. We halt the action cascade by simply returning
+    //   // here without calling emitAppliedActionToParent.
+    //   //
+    //   // NOTE: SubtreeManager has an additional case for PARTIAL_TREE_RENDERING, but we
+    //   // can just assume that using ComposeWorkflow at all implies that optimization.
+    //   //
+    //   // If our child state changed, we need to report that ours did too, as per the
+    //   // comment in StatefulWorkflowNode.applyAction.
+    //   return appliedActionFromChild.withOutput(null)
+    // }
 
     // The child DID emit an output, so we need to call our handler, which will zero or
     // more of two things: (1) change our state, (2) emit an output.
@@ -340,18 +355,29 @@ internal class ComposeWorkflowChildNode<PropsT, OutputT, RenderingT>(
     // directly. But only for the first call to emitOutput – subsequent calls will need to
     // be handled as usual.
     var maybeParentResult: ActionProcessingResult? = null
-    onEmitOutputOverride = { output ->
-      // We can't know if our own state changed, so just propagate from the child.
-      val applied = appliedActionFromChild.withOutput(WorkflowOutput(output))
-      maybeParentResult = emitAppliedActionToParent(applied)
 
-      // Immediately allow any future emissions in the same onOutput call to pass through.
+    if (outputFromChild != null && onOutput != null) {
+      onEmitOutputOverride = { output ->
+        // We can't know if our own state changed, so just propagate from the child.
+        val applied = appliedActionFromChild.withOutput(WorkflowOutput(output))
+        log("handler emitted output, propagating to parent…")
+        maybeParentResult = emitAppliedActionToParent(applied)
+
+        // Immediately allow any future emissions in the same onOutput call to pass through.
+        onEmitOutputOverride = null
+      }
+      // Ask this workflow to handle the child's output. It may write snapshot state or call
+      // emitOutput.
+      onOutput(outputFromChild.value)
       onEmitOutputOverride = null
     }
-    // Ask this workflow to handle the child's output. It may write snapshot state or call
-    // emitOutput.
-    onOutput(outputFromChild.value)
-    onEmitOutputOverride = null
+
+    if (maybeParentResult == null) {
+      // onOutput did not call emitOutput, but we need to propagate the action cascade anyway to
+      // check if state changed.
+      log("handler did not emitOutput, propagating to parent anyway…")
+      maybeParentResult = emitAppliedActionToParent(appliedActionFromChild.withOutput(null))
+    }
 
     // If maybeParentResult is not null then onOutput called emitOutput.
     return maybeParentResult ?: appliedActionFromChild.withOutput(null)