IssueTracker

Using runtime alpha03

Forgive, for a moment, a supremely contrived example: Let's say I have code prints the numbers from 0 to 10 with a delay.

runBlocking {
  var count = 0
  repeat(11) {
    println("The count is: $count")
    delay(250)
    count++
  }
}

This prints

The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
The count is: 9
The count is: 10

and then the program exits.

Unfortunately I'm mixing state, logic, and presentation. Compose let's me clearly delineate these. So I rewrite my code to:

composition.setContent {
  // State
  var count by remember { mutableStateOf(0) }

  // Presentation
  println("The count is: $count")

  // Logic
  launchInComposition {
    repeat(10) {
      delay(250)
      count++
    }
  }
}

(Please ignore the fact that I'm relying on side-effects to print, normally I would use a node in the tree and print when needed as part of a frame)

This code isn't enough on its own, so we have to set up the composition and a frame clock inside main's runBlocking:

fun main() {
  runBlocking {
    val blockingScope = this

    val clock = BroadcastFrameClock()
    val clockJob = launch {
      println("Clock start")
      while (true) {
        clock.sendFrame(0L)
        delay(50)
      }
    }
    clockJob.invokeOnCompletion {
      println("Clock end")
    }

    // This scope encapsulates the work required to render a composition.
    val recomposeJob: Job
    coroutineScope {
      val composeContext = coroutineContext + clock

      val mainThread = Thread.currentThread()
      val embeddingContext = object : EmbeddingContext {
        override fun isMainThread(): Boolean {
          return Thread.currentThread() === mainThread
        }

        override fun mainThreadCompositionContext(): CoroutineContext {
          return composeContext
        }
      }
      yoloGlobalEmbeddingContext = embeddingContext

      val recomposer = Recomposer(embeddingContext)
      val composition = compositionFor(Any(), NoOpApplier, recomposer)

      println("Recompose start")
      // This runs outside of the current coroutineScope because we do not want it to stop this
      // scope from exiting cleanly (at which point we will cancel this job).
      recomposeJob = blockingScope.launch(start = UNDISPATCHED, context = blockingScope.coroutineContext + clock) {
        recomposer.runRecomposeAndApplyChanges()
      }
      recomposeJob.invokeOnCompletion {
        println("Recompose end")
      }

      println("Content start")
      composition.setContent {
        // State
        var count by remember { mutableStateOf(0) }

        // Presentation
        println("The count is: $count")

        // Logic
        launchInComposition {
          repeat(10) {
            delay(250)
            count++
          }
        }
      }
    }
    println("Content end")
    recomposeJob.cancel()
    clockJob.cancel()
  }
}

object NoOpApplier : AbstractApplier<Nothing?>(null) {
  override fun insert(index: Int, instance: Nothing?) {}
  override fun remove(index: Int, count: Int) {}
  override fun move(from: Int, to: Int, count: Int) {}
  override fun onClear() {}
}

yoloGlobalEmbeddingContext looks like this in my runtime which is built for the JVM:

// TODO https://issuetracker.google.com/issues/168110493
var yoloGlobalEmbeddingContext: EmbeddingContext? = null

actual fun EmbeddingContext(): EmbeddingContext = yoloGlobalEmbeddingContext!!

This code prints:

Recompose start
Content start
The count is: 0
Clock start
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
The count is: 9
The count is: 10

and does not exit cleanly.

Unless I'm missing something, there doesn't seem to be a way to set up a composition so that it can exit cleanly when it has no more work to do. I believe this is caused by the FrameManager using Recomposer.current() which references the global EmbeddingContext.

In the context of Android or desktop where a composition runs for as long as it's visible, a coroutine that suspends forever or is tied to the visible lifecycle can be used to keep the composition alive.

One other notable thing: The semi-cyclic dependency where I have to set up the coroutineScope which encapsulates the work, pass it to the Recomposer, but then launch runRecomposeAndApplyChanges outside of that scope to avoid keeping it alive forever is awkward. Perhaps issue 168110493 will help here.