SystemUI: Smoother seekbar for ongoing chip popup ui

Bug Fixes:
1. Seekbar can't be used when paused.
2. The controller polls position every MEDIA_UPDATE_INTERVAL_MS = 1000ms,
   so progressFraction only changes once per second, causing the bar to jump
   in 1-second steps creating visible jitter when moved manually.

Signed-off-by: Pranav Vashi <neobuddy89@gmail.com>

Author: neobuddy89

packages/SystemUI/src/com/android/systemui/statusbar/OnGoingActionProgressController.kt

@@ -677,7 +677,10 @@ class OnGoingActionProgressController(
     fun onSeek(fraction: Float) {
         val duration = mediaSessionHelper.getTotalDuration()
         if (duration <= 0) return
-        mediaSessionHelper.seekTo((fraction * duration).toLong().coerceIn(0L, duration))
+        val seekPos = (fraction * duration).toLong().coerceIn(0L, duration)
+        mediaSessionHelper.seekTo(seekPos)
+        currentProgress = seekPos.toInt()
+        updateProgressState()
         collapseExpandViewWithDelay()
         collapseMediaControlsWithDelay()
     }

packages/SystemUI/src/com/android/systemui/statusbar/OngoingActionProgressCompose.kt

@@ -54,6 +54,7 @@ import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -104,6 +105,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
@@ -472,7 +474,8 @@ private fun MiniMediaPlayer(
                 }
 
                 SeekBarCompose(
-                    progressFraction = progressFraction(state),
+                    progressMs = progressMs,
+                    durationMs = durationMs,
                     isPlaying = state.isMediaPlaying,
                     onSeek = onSeek,
                     modifier = Modifier.fillMaxWidth().height(28.dp)
@@ -571,13 +574,38 @@ private fun ControlButton(
 
 @Composable
 private fun SeekBarCompose(
-    progressFraction: Float,
+    progressMs: Long,
+    durationMs: Long,
     isPlaying: Boolean,
     onSeek: (Float) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     var isScrubbing by remember { mutableStateOf(false) }
 
+    val onSeekRef = rememberUpdatedState(onSeek)
+
+    val serverFraction = if (durationMs > 0) (progressMs.toFloat() / durationMs).coerceIn(0f, 1f) else 0f
+    var displayFraction by remember { mutableStateOf(serverFraction) }
+
+    LaunchedEffect(progressMs, durationMs, isPlaying) {
+        if (isScrubbing) return@LaunchedEffect
+
+        displayFraction = serverFraction
+
+        if (!isPlaying || durationMs <= 0) return@LaunchedEffect
+
+        val startWallMs = System.currentTimeMillis()
+        val startProgressMs = progressMs
+        while (true) {
+            delay(16L) // ~60 fps
+            if (isScrubbing) break
+            val elapsed = System.currentTimeMillis() - startWallMs
+            val interpolated = ((startProgressMs + elapsed).toFloat() / durationMs).coerceIn(0f, 1f)
+            displayFraction = interpolated
+            if (interpolated >= 1f) break
+        }
+    }
+
     AndroidView(
         factory = { ctx ->
             SeekBar(ctx).apply {
@@ -632,26 +660,25 @@ private fun SeekBarCompose(
 
                 setOnSeekBarChangeListener(
                     object : SeekBar.OnSeekBarChangeListener {
-                        override fun onProgressChanged(sb: SeekBar?, v: Int, fromUser: Boolean) {
-                            if (fromUser) onSeek(v / 10_000f)
-                        }
+                        override fun onProgressChanged(sb: SeekBar?, v: Int, fromUser: Boolean) = Unit
 
                         override fun onStartTrackingTouch(sb: SeekBar?) {
                             isScrubbing = true
                         }
 
                         override fun onStopTrackingTouch(sb: SeekBar?) {
+                            sb?.let { onSeekRef.value(it.progress / 10_000f) }
                             isScrubbing = false
                         }
                     }
                 )
             }
         },
         update = { bar ->
-            val target = (progressFraction * 10_000f).toInt().coerceIn(0, 10_000)
+            val target = (displayFraction * 10_000f).toInt().coerceIn(0, 10_000)
 
             if (!isScrubbing) {
-                // Keep QS reset behavior if you want it
+                // Keep QS reset behaviour for track-restart detection.
                 if (
                     target <= SeekBarObserver.RESET_ANIMATION_THRESHOLD_MS &&
                         bar.progress > SeekBarObserver.RESET_ANIMATION_THRESHOLD_MS