[DNM] Introduce ViewFactoryTransformer with vibrating demo effect.

Author: zach-klippenstein

core-compose/src/main/java/com/squareup/workflow/ui/compose/ComposeViewFactory.kt

@@ -87,8 +87,8 @@ inline fun <reified RenderingT : Any> bindCompose(
 ): ViewFactory<RenderingT> = ComposeViewFactory(RenderingT::class, showRendering)
 
 @PublishedApi
-internal class ComposeViewFactory<RenderingT : Any>(
-  override val type: KClass<RenderingT>,
+internal class ComposeViewFactory<in RenderingT : Any>(
+  override val type: KClass<in RenderingT>,
   private val content: @Composable() (RenderingT, ViewEnvironment) -> Unit
 ) : ViewFactory<RenderingT> {
 

core-compose/src/main/java/com/squareup/workflow/ui/compose/ExplodingViewFactoryTransformer.kt

@@ -0,0 +1,69 @@
+package com.squareup.workflow.ui.compose
+
+import androidx.animation.AnimatedFloat
+import androidx.animation.AnimationEndReason.TargetReached
+import androidx.compose.Composable
+import androidx.compose.getValue
+import androidx.compose.mutableStateOf
+import androidx.compose.onCommit
+import androidx.compose.setValue
+import androidx.ui.animation.animatedFloat
+import androidx.ui.core.DensityAmbient
+import androidx.ui.core.Modifier
+import androidx.ui.core.drawLayer
+import androidx.ui.unit.dp
+import kotlin.random.Random
+
+/**
+ * TODO write documentation
+ */
+class ExplodingViewFactoryTransformer(
+  min: Int = -1,
+  max: Int = 1
+) {
+
+  var min by mutableStateOf(min.toFloat())
+  var max by mutableStateOf(max.toFloat())
+
+  val transformer: ViewFactoryTransformer = { _, _ -> transform() }
+
+  @Composable private fun transform(): Modifier {
+    val offsetXDp = animatedFloat(0f)
+    val offsetYDp = animatedFloat(0f)
+
+    onCommit(min, max) {
+      if (min == 0f && max == 0f) {
+        offsetXDp.animateTo(0f)
+        offsetYDp.animateTo(0f)
+      } else {
+        offsetXDp.startPulseAnimation(min, max)
+        offsetYDp.startPulseAnimation(min, max)
+      }
+    }
+
+    if (!offsetXDp.isRunning && !offsetYDp.isRunning) {
+      println("OMG [invoke] not animating, returning early")
+      return Modifier
+    }
+
+    val offsetXPx = with(DensityAmbient.current) { offsetXDp.value.dp.toPx() }
+    val offsetYPx = with(DensityAmbient.current) { offsetYDp.value.dp.toPx() }
+    return Modifier.drawLayer(translationX = offsetXPx.value, translationY = offsetYPx.value)
+  }
+
+  private fun AnimatedFloat.startPulseAnimation(
+    min: Float,
+    max: Float
+  ) {
+    fun animate() {
+      val target = Random.nextDouble(min.toDouble(), max.toDouble())
+          .toFloat()
+      animateTo(target) { reason, _ ->
+        if (reason == TargetReached) {
+          if (min != 0f || max != 0f) animate()
+        }
+      }
+    }
+    animate()
+  }
+}

core-compose/src/main/java/com/squareup/workflow/ui/compose/ViewFactoryTransformer.kt

@@ -0,0 +1,69 @@
+@file:Suppress("RemoveEmptyParenthesesFromAnnotationEntry")
+
+package com.squareup.workflow.ui.compose
+
+import androidx.compose.Composable
+import androidx.compose.remember
+import androidx.ui.core.Modifier
+import com.squareup.workflow.ui.ViewEnvironment
+import com.squareup.workflow.ui.ViewEnvironmentKey
+import com.squareup.workflow.ui.ViewFactory
+import com.squareup.workflow.ui.ViewRegistry
+import com.squareup.workflow.ui.compose.internal.showRendering
+import kotlin.reflect.KClass
+
+/**
+ * TODO write documentation
+ */
+typealias ViewFactoryTransformer = @Composable() (
+  renderingDepth: Int,
+  viewEnvironment: ViewEnvironment
+) -> Modifier
+
+/**
+ * TODO kdoc
+ */
+fun ViewRegistry.modifyViewFactories(transformer: ViewFactoryTransformer): ViewRegistry =
+  TransformedViewRegistry(this, transformer)
+
+private class TransformedViewRegistry(
+  private val delegate: ViewRegistry,
+  private val transformer: ViewFactoryTransformer
+) : ViewRegistry {
+  override val keys: Set<KClass<*>> = delegate.keys
+
+  override fun <RenderingT : Any> getFactoryFor(
+    renderingType: KClass<out RenderingT>
+  ): ViewFactory<RenderingT> {
+    @Suppress("UNCHECKED_CAST")
+    val realFactory = delegate.getFactoryFor(renderingType) as ViewFactory<Any>
+    println("OMG [TVR] got real factory for $renderingType: $realFactory")
+    RuntimeException().printStackTrace()
+
+    @Suppress("UNCHECKED_CAST")
+    return ComposeViewFactory(renderingType as KClass<RenderingT>) { rendering, environment ->
+      // No need to key depth on the environment, the depth will never change.
+      val depth = remember { environment[FactoryDepthKey] }
+      remember { println("OMG [TVR] creating CVF for depth $depth") }
+
+      val childEnvironment = remember(environment) {
+        environment + (FactoryDepthKey to depth + 1)
+      }
+      val modifier = transformer(depth, environment)
+
+      // TODO this causes infinite recursion, because VF.showRendering calls
+      // WorkflowViewStub.update, which will look up the factory again, get this one, try showing
+      // again,
+      realFactory.showRendering(rendering, childEnvironment, modifier)
+    }
+  }
+
+  /**
+   * Values actually encode both depth and prevent infinite looping.
+   * Even values mean the factory should do processing, odd values mean
+   * direct pass-through.
+   */
+  private object FactoryDepthKey : ViewEnvironmentKey<Int>(Int::class) {
+    override val default: Int get() = 0
+  }
+}

core-compose/src/main/java/com/squareup/workflow/ui/compose/internal/ForkedViewStub.kt

@@ -0,0 +1,72 @@
+package com.squareup.workflow.ui.compose.internal
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.View
+import android.view.ViewGroup
+import com.squareup.workflow.ui.ViewEnvironment
+import com.squareup.workflow.ui.ViewFactory
+import com.squareup.workflow.ui.canShowRendering
+import com.squareup.workflow.ui.showRendering
+
+/**
+ * TODO write documentation
+ */
+internal class ForkedViewStub @JvmOverloads constructor(
+  context: Context,
+  attributeSet: AttributeSet? = null,
+  defStyle: Int = 0,
+  defStyleRes: Int = 0
+) : View(context, attributeSet, defStyle, defStyleRes) {
+  init {
+    setWillNotDraw(true)
+  }
+
+  /**
+   * On-demand access to the delegate established by the last call to [update],
+   * or this [ForkedViewStub] instance if  none has yet been set.
+   */
+  var actual: View = this
+
+  /**
+   * Replaces this view with one that can display [rendering]. If the receiver
+   * has already been replaced, updates the replacement if it [canShowRendering].
+   * If the current replacement can't handle [rendering], a new view is put in place.
+   *
+   * @return the view that showed [rendering]
+   *
+   * @throws IllegalArgumentException if no binding can be find for the type of [rendering]
+   *
+   * @throws IllegalStateException if the matching [ViewFactory] fails to call
+   * [View.bindShowRendering] when constructing the view
+   */
+  fun update(
+    rendering: Any,
+    viewEnvironment: ViewEnvironment,
+    viewFactory: ViewFactory<Any>
+  ): View {
+    actual.takeIf { it.canShowRendering(rendering) }
+        ?.let {
+          it.showRendering(rendering, viewEnvironment)
+          return it
+        }
+
+    return when (val parent = actual.parent) {
+      is ViewGroup -> viewFactory.buildView(rendering, viewEnvironment, parent.context, parent)
+          .also { buildNewViewAndReplaceOldView(parent, it) }
+      else -> viewFactory.buildView(rendering, viewEnvironment, actual.context)
+    }.also { actual = it }
+  }
+
+  private fun buildNewViewAndReplaceOldView(
+    parent: ViewGroup,
+    newView: View
+  ) {
+    val index = parent.indexOfChild(actual)
+    parent.removeView(actual)
+
+    actual.layoutParams
+        ?.let { parent.addView(newView, index, it) }
+        ?: run { parent.addView(newView, index) }
+  }
+}

core-compose/src/main/java/com/squareup/workflow/ui/compose/internal/ViewFactories.kt

@@ -62,7 +62,7 @@ import com.squareup.workflow.ui.compose.internal.ComposableViewStubWrapper.Updat
       // IntelliJ currently complains very loudly about this function call, but it actually
       // compiles. The IDE tooling isn't currently able to recognize that the Compose compiler
       // accepts this code.
-      ComposableViewStubWrapper(update = Update(rendering, newEnvironment))
+      ComposableViewStubWrapper(update = Update(rendering, newEnvironment, this))
     }
   }
 }
@@ -79,18 +79,19 @@ private class ComposableViewStubWrapper(context: Context) : FrameLayout(context)
 
   data class Update(
     val rendering: Any,
-    val viewEnvironment: ViewEnvironment
+    val viewEnvironment: ViewEnvironment,
+    val viewFactory: ViewFactory<Any>
   )
 
-  private val viewStub = WorkflowViewStub(context)
+  private val viewStub = ForkedViewStub(context)
 
   init {
     addView(viewStub)
   }
 
   // Compose turns this into a parameter when you invoke this class as a Composable.
   fun setUpdate(update: Update) {
-    viewStub.update(update.rendering, update.viewEnvironment)
+    viewStub.update(update.rendering, update.viewEnvironment, update.viewFactory)
   }
 
   override fun getLayoutParams(): LayoutParams = LayoutParams(MATCH_PARENT, MATCH_PARENT)

samples/nested-renderings/src/main/java/com/squareup/sample/nestedrenderings/NestedRenderingsActivity.kt

@@ -18,31 +18,51 @@ package com.squareup.sample.nestedrenderings
 import android.os.Bundle
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.Providers
+import androidx.compose.getValue
+import androidx.compose.setValue
+import androidx.compose.state
+import androidx.ui.core.setContent
 import androidx.ui.graphics.Color
+import androidx.ui.layout.Column
+import androidx.ui.material.Slider
 import com.squareup.workflow.diagnostic.SimpleLoggingDiagnosticListener
 import com.squareup.workflow.ui.ViewEnvironment
 import com.squareup.workflow.ui.ViewRegistry
-import com.squareup.workflow.ui.WorkflowRunner
+import com.squareup.workflow.ui.compose.ExplodingViewFactoryTransformer
+import com.squareup.workflow.ui.compose.WorkflowContainer
+import com.squareup.workflow.ui.compose.modifyViewFactories
+import com.squareup.workflow.ui.compose.showRendering
 import com.squareup.workflow.ui.compose.withComposeViewFactoryRoot
-import com.squareup.workflow.ui.setContentWorkflow
 
 private val viewRegistry = ViewRegistry(
     RecursiveViewFactory,
     LegacyRunner
 )
+private val exploder = ExplodingViewFactoryTransformer()
 
-private val viewEnvironment = ViewEnvironment(viewRegistry).withComposeViewFactoryRoot { content ->
+private val viewEnvironment = ViewEnvironment(
+    viewRegistry.modifyViewFactories(exploder.transformer)
+).withComposeViewFactoryRoot { content ->
   Providers(BackgroundColorAmbient provides Color.Green, children = content)
 }
 
 class NestedRenderingsActivity : AppCompatActivity() {
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
-    setContentWorkflow(viewEnvironment) {
-      WorkflowRunner.Config(
-          RecursiveWorkflow,
-          diagnosticListener = SimpleLoggingDiagnosticListener()
-      )
+    setContent {
+      var vibrateRange by state { 0f }
+      Column {
+        Slider(value = vibrateRange, onValueChange = {
+          vibrateRange = it
+          exploder.min = -it
+          exploder.max = it
+        }, valueRange = 0f..10f)
+
+        WorkflowContainer(
+            RecursiveWorkflow,
+            diagnosticListener = SimpleLoggingDiagnosticListener()
+        ) { viewEnvironment.showRendering(it) }
+      }
     }
   }
 }