[ui-compose] Eliminate race condition in PresentationState

PresentationState creation and listener registration are not an atomic operation. This happens because the LaunchedEffect which starts the listen-to-Player-Events coroutine can be pre-empted with other side effects, including the ones that change something in the Player.

rememberPresentationState function creates a PresentationState object and initialises it with the correct fresh values pulled out of the Player. The subscription to Player events with a registration of a Listener (via PresentationState.observe()) is not immediate. It *returns* immediately, but is instead scheduled to happen later, although within the same Handler message. Other LaunchedEffects could have been scheduled earlier and could take place between the button state creation and listener subscription.

This is not a problem if no changes to the player happen, but if we miss the relevant player events, we might end up with a UI that is out of sync with reality. The way to fix this is to pull the latest values out of the Player on demand upon starting to listen to Player events.

PiperOrigin-RevId: 753129489

Author: oceanjules

libraries/ui_compose/src/main/java/androidx/media3/ui/compose/state/PresentationState.kt

@@ -83,7 +83,9 @@ class PresentationState(private val player: Player) {
    * * [Player.EVENT_RENDERED_FIRST_FRAME] and [Player.EVENT_TRACKS_CHANGED]to determine whether the
    *   surface is ready to be shown
    */
-  suspend fun observe(): Nothing =
+  suspend fun observe() {
+    videoSizeDp = getVideoSizeDp(player)
+    coverSurface = true
     player.listen { events ->
       if (events.contains(Player.EVENT_VIDEO_SIZE_CHANGED)) {
         if (videoSize != VideoSize.UNKNOWN && playbackState != Player.STATE_IDLE) {
@@ -98,6 +100,7 @@ class PresentationState(private val player: Player) {
         maybeHideSurface(player)
       }
     }
+  }
 
   @Nullable
   private fun getVideoSizeDp(player: Player): Size? {

libraries/ui_compose/src/test/java/androidx/media3/ui/compose/state/PresentationStateTest.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.media3.ui.compose.state
+
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.media3.common.Player
+import androidx.media3.common.VideoSize
+import androidx.media3.ui.compose.utils.TestPlayer
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Unit test for [PresentationState]. */
+@RunWith(AndroidJUnit4::class)
+class PresentationStateTest {
+
+  @get:Rule val composeTestRule = createComposeRule()
+
+  @Test
+  fun playerInitialized_presentationStateInitialized() {
+    val player = TestPlayer()
+    player.playbackState = Player.STATE_IDLE
+
+    lateinit var state: PresentationState
+    composeTestRule.setContent { state = rememberPresentationState(player) }
+
+    assertThat(state.coverSurface).isTrue()
+    assertThat(state.keepContentOnReset).isFalse()
+    assertThat(state.videoSizeDp).isEqualTo(null)
+  }
+
+  @Test
+  fun playerChangesVideoSizeBeforeEventListenerRegisters_observeGetsTheLatestValues_uiInSync() {
+    val player = TestPlayer()
+    player.playbackState = Player.STATE_IDLE
+
+    lateinit var state: PresentationState
+    composeTestRule.setContent {
+      // Schedule LaunchedEffect to update player state before PresentationState is created.
+      // This update could end up being executed *before* PresentationState schedules the start
+      // of event listening and we don't want to lose it.
+      LaunchedEffect(player) { player.videoSize = VideoSize(480, 360) }
+      state = rememberPresentationState(player)
+    }
+
+    assertThat(state.videoSizeDp).isEqualTo(Size(480f, 360f))
+    assertThat(state.coverSurface).isTrue()
+    assertThat(state.keepContentOnReset).isFalse()
+  }
+}

libraries/ui_compose/src/test/java/androidx/media3/ui/compose/utils/TestPlayer.kt

@@ -20,6 +20,7 @@ import android.os.Looper
 import androidx.media3.common.PlaybackParameters
 import androidx.media3.common.Player
 import androidx.media3.common.SimpleBasePlayer
+import androidx.media3.common.VideoSize
 import com.google.common.collect.ImmutableList
 import com.google.common.util.concurrent.Futures
 import com.google.common.util.concurrent.ListenableFuture
@@ -124,6 +125,11 @@ internal class TestPlayer : SimpleBasePlayer(Looper.myLooper()!!) {
     invalidateState()
   }
 
+  fun setVideoSize(videoSize: VideoSize) {
+    state = state.buildUpon().setVideoSize(videoSize).build()
+    invalidateState()
+  }
+
   fun removeCommands(vararg commands: @Player.Command Int) {
     // It doesn't seem possible to propagate the @IntDef annotation through Kotlin's spread operator
     // in a way that lint understands.