[ui-compose] Round up current position of ProgressStateWithTickInterval

Until this change, `currentPositionMs` and `bufferedPositionMs` were a direct value extracted from the underlying Player. This resulted in the consumer having to make decisions about how to round up the value for the final display (e.g. how to parse the milliseconds into the HH:MM:SS string).

Whatever the user has provided as the interval is most likely the granularity they desire for the `currentPositionMs` and `bufferedPositionMs`. And while we attempt to poll the Player at exactly this interval, it is not always possible to obtain a precise value that is a multiple of the interval (e.g. falls directly on the grid of [0, interval, 2xinterval, 3xinterval ...]).

This change ensures that the `currentPositionMs` and `bufferedPositionMs` returned by `ProgressStateWithTickInterval` is already rounded up correctly. Note that it will still act like a "stopwatch" and not jump to the next second/minute value until we are incredibly close to the boundary (i.e. not from 50% of the interval or 50% of the remaining minute). Instead, this boundary is defined at 10ms to account for any potential jitter in Player reporting its current position.

PiperOrigin-RevId: 781159734

Author: oceanjules

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

@@ -88,7 +88,7 @@ fun rememberProgressStateWithTickInterval(
  *   to some UI element, the scope of the Composable will ensure the job is cancelled when the
  *   element is disposed.
  * @property[currentPositionMs] The playback position in the current content or ad, in milliseconds,
- *   matches [Player.getCurrentPosition].
+ *   matches [Player.getCurrentPosition] that is rounded to a multiple of [tickIntervalMs].
  * @property[bufferedPositionMs] An estimate of the position in the current content or ad up to
  *   which data is buffered, in milliseconds.
  * @property[durationMs] The duration of the current content or ad in milliseconds, matches
@@ -100,10 +100,12 @@ class ProgressStateWithTickInterval(
   @IntRange(from = 0) private val tickIntervalMs: Long = 0,
   scope: CoroutineScope,
 ) {
-  var currentPositionMs by mutableLongStateOf(getCurrentPositionMsOrDefault(player))
+  var currentPositionMs by
+    mutableLongStateOf(snapPositionToNearestTick(player, ::getCurrentPositionMsOrDefault))
     private set
 
-  var bufferedPositionMs by mutableLongStateOf(getBufferedPositionMsOrDefault(player))
+  var bufferedPositionMs by
+    mutableLongStateOf(snapPositionToNearestTick(player, ::getBufferedPositionMsOrDefault))
     private set
 
   var durationMs by mutableLongStateOf(getDurationMsOrDefault(player))
@@ -115,8 +117,8 @@ class ProgressStateWithTickInterval(
       scope,
       nextMediaTickMsSupplier = ::nextMediaWakeUpPositionMs,
       scheduledTask = {
-        currentPositionMs = getCurrentPositionMsOrDefault(player)
-        bufferedPositionMs = getBufferedPositionMsOrDefault(player)
+        currentPositionMs = snapPositionToNearestTick(player, ::getCurrentPositionMsOrDefault)
+        bufferedPositionMs = snapPositionToNearestTick(player, ::getBufferedPositionMsOrDefault)
         durationMs = getDurationMsOrDefault(player)
       },
     )
@@ -144,4 +146,22 @@ class ProgressStateWithTickInterval(
     }
     return nextMediaWakeUpPositionMs
   }
+
+  /**
+   * Round the actual position to the nearest tick (i.e. integer number of tickIntervals). Rounding
+   * happens in a stop-watch manner, i.e. always down - hence integer division.
+   *
+   * Note how this is different to [ProgressStateWithTickCount] rounding that takes half of the
+   * interval into account to round up.
+   */
+  private fun snapPositionToNearestTick(player: Player, positionSupplier: (Player) -> Long): Long {
+    val actualPositionMs = positionSupplier(player)
+    if (tickIntervalMs == 0L || actualPositionMs % tickIntervalMs == 0L) {
+      return actualPositionMs
+    }
+    val adjustedCurrentTick = (actualPositionMs + POSITION_CORRECTION_OFFSET_MS) / tickIntervalMs
+    return adjustedCurrentTick * tickIntervalMs
+  }
 }
+
+private const val POSITION_CORRECTION_OFFSET_MS = 10

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

@@ -98,6 +98,40 @@ class ProgressStateWithTickIntervalTest {
       assertThat(state.currentPositionMs).isEqualTo(2000)
     }
 
+  @Test
+  fun progressUpdatingOnTheSecondMark_moveClockByFractionalSeconds_positionRoundsUpToTheGrid() =
+    runTest(testDispatcher) {
+      val player =
+        TestPlayer(
+          playWhenReady = true,
+          playlist = listOf(MediaItemData.Builder("SingleItem").build()),
+        )
+      player.setPositionSupplierDrivenBy(testDispatcher.scheduler)
+      lateinit var state: ProgressStateWithTickInterval
+      composeTestRule.setContent {
+        state =
+          rememberProgressStateWithTickInterval(
+            player,
+            tickIntervalMs = 500,
+            scope = backgroundScope,
+          )
+      }
+
+      advanceTimeByInclusive(1800.milliseconds)
+      player.setDuration("SingleItem", 5000)
+      composeTestRule.waitForIdle()
+
+      assertThat(player.currentPosition).isEqualTo(1800)
+      assertThat(state.currentPositionMs).isEqualTo(1500)
+
+      advanceTimeByInclusive(195.milliseconds)
+      player.setDuration("SingleItem", 7000)
+      composeTestRule.waitForIdle()
+
+      assertThat(player.currentPosition).isEqualTo(1995)
+      assertThat(state.currentPositionMs).isEqualTo(2000)
+    }
+
   @Test
   fun progressUpdatingContinuouslyEveryFrame_positionChangesByOneFrame() =
     runTest(testDispatcher) {
@@ -202,17 +236,17 @@ class ProgressStateWithTickIntervalTest {
       advanceTimeByInclusive(666.milliseconds)
 
       assertThat(player.currentPosition).isEqualTo(999)
-      assertThat(state.currentPositionMs).isEqualTo(999)
+      assertThat(state.currentPositionMs).isEqualTo(1000)
 
       advanceTimeByInclusive(400.milliseconds)
 
       assertThat(player.currentPosition).isEqualTo(1599)
-      assertThat(state.currentPositionMs).isEqualTo(999) // doesn't ever reach 1000
+      assertThat(state.currentPositionMs).isEqualTo(1000)
 
       advanceTimeByInclusive(267.milliseconds)
 
       assertThat(player.currentPosition).isEqualTo(1999)
-      assertThat(state.currentPositionMs).isEqualTo(1999) // first bump since 999
+      assertThat(state.currentPositionMs).isEqualTo(2000)
 
       advanceTimeByInclusive(667.milliseconds)
 
@@ -321,7 +355,7 @@ class ProgressStateWithTickIntervalTest {
         state =
           rememberProgressStateWithTickInterval(
             player,
-            tickIntervalMs = 5000,
+            tickIntervalMs = 100,
             scope = backgroundScope,
           )
       }
@@ -337,7 +371,7 @@ class ProgressStateWithTickIntervalTest {
       advanceTimeByInclusive((PAUSED_UPDATE_INTERVAL_MS - 500).milliseconds)
 
       assertThat(player.bufferedPosition).isEqualTo(123)
-      assertThat(state.bufferedPositionMs).isEqualTo(123)
+      assertThat(state.bufferedPositionMs).isEqualTo(100)
     }
 
   /**