Align scene snapshot-apply to Android; tidy FrameRecomposer queue naming

Replaces the un-Android between-phase Snapshot.sendApplyNotifications() that
postponeInvalidation ran around every scene operation with the apply model
Android actually uses.

- postponeInvalidation no longer applies between the measure/layout and draw
  sub-phases; Android's Choreographer runs measure -> layout -> draw in one
  traversal and never applies between phases.
- BaseComposeScene.draw() advances the global snapshot via
  Snapshot.notifyObjectsInitialized() right before drawing, mirroring
  AndroidComposeView.dispatchDraw (post-385d71d1ec5): lighter than
  sendApplyNotifications and coalesces a placement-write cascade into one frame.
- FrameRecomposer.performFrame drives applies via its pump + the per-context
  GlobalSnapshotManager, so deferred owner-invalidation lands on frame/input
  boundaries.
- OffsetToFocusedRect: document the remaining between-phase-apply dependency
  (iOS FocusableAboveKeyboard) as a FIXME.

Also tidies FrameRecomposer's two-queue naming to match AndroidUiDispatcher:
effectDispatcher/recomposeDispatcher -> trampolineDispatcher/frameDispatcher and
performScheduledEffects/performScheduledRecomposerTasks ->
performTrampolineDispatch/performFrameDispatch, with KDoc stating each rolls its
loop synchronously.

Author: MatkovIvan

compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/layout/OffsetToFocusedRect.skiko.kt

@@ -97,6 +97,10 @@ internal fun OffsetToFocusedRect(
             // Intentionally update state within composition to trigger second measure and
             // layout because focus rect may be miscalculated due to simultaneous offset and
             // window insets changes.
+            //
+            // FIXME: this "second measure" only settles in-frame because BaseComposeScene.draw()
+            //  currently calls Snapshot.sendApplyNotifications() between the measure and draw phases -
+            //  a temporary, un-Android workaround kept solely for this code path.
             currentOffset = startOffset + (endOffset - startOffset) * offsetProgress
 
             val placeables = measurables.fastMap { it.measure(constraints) }

compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/platform/FrameRecomposer.skiko.kt

@@ -40,22 +40,21 @@ import kotlinx.coroutines.withContext
  * (`AndroidComposeView` + the host recomposer + `Choreographer`).
  *
  * Two work queues mirror `AndroidUiDispatcher`'s two queues:
- * - [effectDispatcher] (Android's `toRunTrampolined`): coroutine dispatch, composition effects
+ * - [trampolineDispatcher] (Android's `toRunTrampolined`): coroutine dispatch, composition effects
  *   (`LaunchedEffect`, `rememberCoroutineScope` launches) and the recomposer's effect context;
- * - [recomposeDispatcher] (Android's `toRunOnFrame`), together with [frameClock]: `withFrameNanos`
- *   awaiters and recomposition (the recomposition loop runs on `recomposeDispatcher + frameClock`).
+ * - [frameDispatcher] (Android's `toRunOnFrame`), together with [frameClock]: `withFrameNanos`
+ *   awaiters and recomposition (the recomposition loop runs on `frameDispatcher + frameClock`).
  *
  * Both are [FlushCoroutineDispatcher]s layered over the host's real dispatcher, so on a host with a
  * live native loop they drain automatically (like Android's `Handler.post`); [performFrame] and the
- * scene phases also drain them explicitly via [performScheduledEffects] /
- * [performScheduledRecomposerTasks].
+ * scene phases also roll them synchronously via [performTrampolineDispatch] / [performFrameDispatch].
  *
  * Android drives frames through `Choreographer.doFrame`; non-Android platforms have no such hook, so
  * the host calls [performFrame] explicitly before driving scene measure/layout and draw.
  *
  * The host dispatcher must be confined to a single thread, so [composeThreadId] is stable - the
  * analog of Android's UI [android.os.Looper] thread. It is recorded whenever the recomposer runs on
- * the host thread (via [performScheduledRecomposerTasks]) and read by [runOnComposeThread].
+ * the host thread (via [performFrameDispatch]) and read by [runOnComposeThread].
  */
 @InternalComposeUiApi
 class FrameRecomposer(
@@ -65,26 +64,32 @@ class FrameRecomposer(
     private val job = Job()
     private val coroutineScope = CoroutineScope(coroutineContext + job)
 
-    /** Trampoline queue: coroutine dispatch / composition effects / scheduled apply notifications. */
-    private val effectDispatcher = FlushCoroutineDispatcher(coroutineScope)
+    /**
+     * Trampoline queue (Android's `toRunTrampolined`): coroutine dispatch / composition effects /
+     * scheduled apply notifications. Rolled synchronously by [performTrampolineDispatch].
+     */
+    private val trampolineDispatcher = FlushCoroutineDispatcher(coroutineScope)
 
-    /** Frame queue: `withFrameNanos` awaiters and recomposition tasks. */
-    private val recomposeDispatcher = FlushCoroutineDispatcher(coroutineScope)
+    /**
+     * Frame queue (Android's `toRunOnFrame`): `withFrameNanos` awaiters and recomposition tasks.
+     * Rolled synchronously by [performFrameDispatch].
+     */
+    private val frameDispatcher = FlushCoroutineDispatcher(coroutineScope)
 
     /**
      * The clock that drives the recomposition loop. Its `withFrameNanos` awaiters are resumed by
      * [performFrame]; new awaiters request a frame via [invalidate].
      */
     private val frameClock = BroadcastFrameClock(::onNewAwaiters)
 
-    private val recomposer = Recomposer(coroutineContext + job + effectDispatcher)
+    private val recomposer = Recomposer(coroutineContext + job + trampolineDispatcher)
 
     /**
      * Id of the host (compose) thread. The analog of Android's check
      * `handler.looper === Looper.myLooper()`: snapshot-observer callbacks run inline when on this
-     * thread, otherwise they are posted to the shared [effectDispatcher].
+     * thread, otherwise they are posted to the shared [trampolineDispatcher].
      *
-     * Recorded only in [performScheduledRecomposerTasks] - i.e. only where the recomposer actually
+     * Recorded only in [performFrameDispatch] - i.e. only where the recomposer actually
      * executes on the host thread (driven by [performFrame] each frame, and by `setContent` so the
      * thread is established before the first frame) - so a stray off-thread call can never corrupt
      * which thread is the compose thread.
@@ -107,7 +112,7 @@ class FrameRecomposer(
             "FrameRecomposer requires a ContinuationInterceptor in its coroutineContext"
         }
         coroutineScope.launch(
-            recomposeDispatcher + frameClock,
+            frameDispatcher + frameClock,
             start = CoroutineStart.UNDISPATCHED
         ) {
             recomposer.runRecomposeAndApplyChanges()
@@ -146,23 +151,8 @@ class FrameRecomposer(
      * the trampoline and run on the next turn (after draw), matching Android.
      */
     fun performFrame(frameTimeNanos: Long) {
-        // It's usually handled by [GlobalSnapshotManager], but currently there are a few places
-        // that require synchronous execution, so this guard is for compatibility.
-        Snapshot.sendApplyNotifications()
-
-        recomposeFrame(frameTimeNanos)
-    }
-
-    /**
-     * Advances only the host recomposer and frame clock by one frame at [frameTimeNanos].
-     */
-    private fun recomposeFrame(frameTimeNanos: Long) {
         postponeFrameInvalidation {
-            // Flush composition effects (e.g. LaunchedEffect, coroutines launched in
-            // rememberCoroutineScope()) queued by the previous turn must run before
-            // recomposition tasks and frame-clock awaiters.
-            performScheduledEffects()
-            performScheduledRecomposerTasks()
+            performFrameDispatch()
 
             frameClock.sendFrame(frameTimeNanos)
         }
@@ -174,8 +164,8 @@ class FrameRecomposer(
     /** Returns whether the host still has recomposition or loop work to process. */
     fun hasPendingWork(): Boolean =
         recomposer.hasPendingWork ||
-            effectDispatcher.hasImmediateTasks() ||
-            recomposeDispatcher.hasImmediateTasks() ||
+            trampolineDispatcher.hasImmediateTasks() ||
+            frameDispatcher.hasImmediateTasks() ||
             frameClock.hasAwaiters
 
     /** Cancels the host recomposer and releases host-owned resources. */
@@ -198,7 +188,7 @@ class FrameRecomposer(
      * Runs [block] on the compose thread: inline when already on it, otherwise [dispatch]ed onto
      * the shared trampoline queue. The non-Android analog of `AndroidComposeView`'s
      * `if (uiThread) cmd() else handler.post(cmd)`. This is the executor for owners' snapshot
-     * observers; off-thread commands therefore ride [effectDispatcher] (one shared queue, like
+     * observers; off-thread commands therefore ride [trampolineDispatcher] (one shared queue, like
      * Android's single UI looper) and are reflected in [hasPendingWork].
      */
     internal fun runOnComposeThread(block: () -> Unit) {
@@ -207,30 +197,40 @@ class FrameRecomposer(
 
     /**
      * Enqueues [block] onto the trampoline queue; it runs on the next loop turn or the next
-     * [performScheduledEffects]. The non-Android analog of `Handler.post`.
+     * [performTrampolineDispatch]. The non-Android analog of `Handler.post`.
      */
     internal fun dispatch(block: () -> Unit) {
-        effectDispatcher.dispatch(job, Runnable(block))
+        trampolineDispatcher.dispatch(job, Runnable(block))
     }
 
     /**
-     * Runs the frame queue (pending `withFrameNanos`/recompose tasks) and records the compose thread:
-     * this is where the recomposer (`runRecomposeAndApplyChanges`) executes on the host thread, so it
-     * is the single place [composeThreadId] is set. Driven by [performFrame] each frame, and by
-     * `BaseComposeScene.setContent` so the compose thread is established before the first frame.
+     * Synchronously rolls the frame loop: drains the [frameDispatcher] queue (pending
+     * `withFrameNanos` / recompose tasks) after first rolling the trampoline loop via
+     * [performTrampolineDispatch]. This is also the single place the recomposer
+     * (`runRecomposeAndApplyChanges`) executes on the host thread, so it is where [composeThreadId]
+     * is recorded. Driven by [performFrame] each frame, and by `BaseComposeScene.setContent` so the
+     * compose thread is established before the first frame.
+     *
+     * The non-Android analog of `AndroidUiDispatcher.performFrameDispatch`.
      */
-    internal fun performScheduledRecomposerTasks(): Unit =
-        trace("FrameRecomposer:performScheduledRecomposerTasks") {
+    internal fun performFrameDispatch(): Unit =
+        trace("FrameRecomposer:performFrameDispatch") {
             composeThreadId = getCurrentThreadId()
-            recomposeDispatcher.flush()
+            performTrampolineDispatch()
+            frameDispatcher.flush()
         }
 
     /**
-     * Runs the trampoline queue (coroutine dispatch / composition effects / scheduled apply
-     * notifications).
+     * Synchronously rolls the trampoline loop: first flushes pending snapshot apply notifications
+     * (so writes made since the last turn are visible to the queued work), then drains the
+     * [trampolineDispatcher] queue (coroutine dispatch / composition effects).
+     *
+     * The non-Android analog of `AndroidUiDispatcher.performTrampolineDispatch`.
      */
-    internal fun performScheduledEffects(): Unit =
-        trace("FrameRecomposer:performScheduledEffects") {
-            effectDispatcher.flush()
+    internal fun performTrampolineDispatch(): Unit =
+        trace("FrameRecomposer:performTrampolineDispatch") {
+            Snapshot.sendApplyNotifications()
+
+            trampolineDispatcher.flush()
         }
 }

compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/scene/BaseComposeScene.skiko.kt

@@ -74,19 +74,8 @@ internal abstract class BaseComposeScene(
             if (isInvalidationDisabled) return block()
             isInvalidationDisabled = true
             return try {
-                // Keep the same scene-boundary snapshot behavior the previous combined render path had
-                // via SnapshotInvalidationTracker.sendAndPerformSnapshotChanges(): first send global
-                // apply notifications, then run only this scene's queued owner-observer callbacks.
-                // This makes snapshot reads that affect layout/draw visible before the phase starts,
-                // but keeps the tracker scene-local;
-                Snapshot.sendApplyNotifications()
-
                 block()
             } finally {
-                // This is the previous wrapper's trailing checkpoint written out explicitly.
-                // It lets state writes produced during the phase enqueue layout/draw invalidations
-                // before the native platform decides whether another layout or draw pass is needed.
-                Snapshot.sendApplyNotifications()
                 isInvalidationDisabled = false
             }.also {
                 invokeInvalidationCallbacks()
@@ -132,7 +121,7 @@ internal abstract class BaseComposeScene(
              * changed parameters can be applied in a separate turn and trigger double
              * recomposition when new content is installed.
              */
-            frameRecomposer.performScheduledRecomposerTasks()
+            frameRecomposer.performFrameDispatch()
             composition?.dispose()
             composition = createComposition(
                 parentCompositionContext = parentCompositionContext ?: frameRecomposer.compositionContext,
@@ -145,7 +134,7 @@ internal abstract class BaseComposeScene(
                     content = content
                 )
             }
-            frameRecomposer.performScheduledRecomposerTasks()
+            frameRecomposer.performFrameDispatch()
         }
 
     override fun measureAndLayout() {
@@ -167,10 +156,25 @@ internal abstract class BaseComposeScene(
         if (isClosed) return
 
         postponeInvalidation("BaseComposeScene:draw") {
+            // FIXME: Remove applying the global snapshot here.
+            //  Android never applies the snapshot *between* the layout and draw phases
+            //  (applies happen once per frame on the main looper, not between phases).
+            //  This between-phase apply is a temporary workaround kept only to preserve current
+            //  behavior for OffsetToFocusedRect (iOS FocusableAboveKeyboard).
+            Snapshot.sendApplyNotifications()
+
             // AndroidComposeView.dispatchDraw() begins with measureAndLayout() so layout changes
             // discovered after the host layout traversal are still settled before drawing. Keep
             // that trailing layout pass here even though measureAndLayout() is also a public phase.
             doMeasureAndLayout()
+
+            // Mirror AndroidComposeView.dispatchDraw (commit 385d71d1ec5): advance the global
+            // snapshot before drawing so writes made since the last pass - including state objects
+            // created during a prior draw (e.g. an Indication node) - are recorded as modified and
+            // visible to this draw. Lighter than sendApplyNotifications (only advances; no
+            // hasPendingChanges guard), and the Android-faithful replacement for the per-phase apply.
+            Snapshot.notifyObjectsInitialized()
+
             doDraw(canvas)
         }
     }
@@ -203,7 +207,7 @@ internal abstract class BaseComposeScene(
             scaleGestureFactor = scaleGestureFactor,
             panGestureOffset = panGestureOffset,
         ).also {
-            frameRecomposer.performScheduledEffects()
+            frameRecomposer.performTrampolineDispatch()
         }
     }
 
@@ -234,7 +238,7 @@ internal abstract class BaseComposeScene(
             scaleGestureFactor = scaleGestureFactor,
             panGestureOffset = panGestureOffset,
         ).also {
-            frameRecomposer.performScheduledEffects()
+            frameRecomposer.performTrampolineDispatch()
         }
     }
 
@@ -245,7 +249,7 @@ internal abstract class BaseComposeScene(
     override fun sendKeyEvent(keyEvent: KeyEvent): Boolean =
         postponeInvalidation("BaseComposeScene:sendKeyEvent") {
             inputHandler.onKeyEvent(keyEvent).also {
-                frameRecomposer.performScheduledEffects()
+                frameRecomposer.performTrampolineDispatch()
             }
         }
 
@@ -260,7 +264,7 @@ internal abstract class BaseComposeScene(
             uptimeMillis = timeMillis
         )
         processRotaryScrollEvent(event).also {
-            frameRecomposer.performScheduledEffects()
+            frameRecomposer.performTrampolineDispatch()
         }
     }