Final optimization for UnifiedPlayerSheetV2.kt and it's related animations, plus changed BenchmarkEnvironment.kt and added PlayerSheetAnimationBenchmark.kt to properly test and benchmark those animations

Author: theovilardo

app/src/main/java/com/theveloper/pixelplay/MainActivity.kt

@@ -61,6 +61,7 @@ import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.lifecycleScope
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -169,6 +170,8 @@ class MainActivity : ComponentActivity() {
     lateinit var userPreferencesRepository: UserPreferencesRepository // Inject here
     @Inject
     lateinit var themePreferencesRepository: ThemePreferencesRepository
+    @Inject
+    lateinit var syncManager: SyncManager
     // For handling shortcut navigation - using StateFlow so composables can observe changes
     private val _pendingPlaylistNavigation = kotlinx.coroutines.flow.MutableStateFlow<String?>(null)
     private val _pendingShuffleAll = kotlinx.coroutines.flow.MutableStateFlow(false)
@@ -207,6 +210,21 @@ class MainActivity : ComponentActivity() {
 
         // LEER SEÑAL DE BENCHMARK
         val isBenchmarkMode = intent.getBooleanExtra("is_benchmark", false)
+        val shouldBenchmarkRebuildDatabase =
+            isBenchmarkMode && intent.getBooleanExtra("benchmark_rebuild_database", false)
+        Log.i(
+            "PixelPlayBenchmark",
+            "onCreate benchmark=$isBenchmarkMode rebuildDatabase=$shouldBenchmarkRebuildDatabase"
+        )
+        if (shouldBenchmarkRebuildDatabase) {
+            lifecycleScope.launch {
+                userPreferencesRepository.setInitialSetupDone(true)
+                Log.i("PixelPlayBenchmark", "Enqueueing benchmark database rebuild")
+                syncManager.rebuildDatabase()
+                delay(1_500L)
+                playerViewModel.prepareBenchmarkPlayerFromLibrary()
+            }
+        }
 
         setContent {
             val systemDarkTheme = isSystemInDarkTheme()

app/src/main/java/com/theveloper/pixelplay/data/worker/SyncWorker.kt

@@ -856,15 +856,17 @@ constructor(
                 }
 
         if (rawDataList.isEmpty()) {
+            Log.i(TAG, "MediaStore cursor produced 0 raw songs after directory filtering")
             Trace.endSection()
             return emptyList()
         }
 
         // Phase 2: Identify changed songs and merge with existing data in chunks
         val artistDelimiters = userPreferencesRepository.artistDelimitersFlow.first()
         val artistWordDelimiters = userPreferencesRepository.artistWordDelimitersFlow.first()
+        val rawSongCount = rawDataList.size
         val songsToProcess = if (isRebuild) {
-             rawDataList
+             rawDataList.toList()
         } else {
             // Find existing data for these songs to avoid unnecessary reprocessing
             // and to preserve user edits.
@@ -886,10 +888,13 @@ constructor(
 
         // rawDataList is no longer needed — release its memory before the processing phase,
         // which may allocate large existingMap objects and metadata ByteArrays.
-        @Suppress("UNUSED_VALUE")
         rawDataList.clear()
 
         val totalCount = songsToProcess.size
+        Log.i(
+            TAG,
+            "MediaStore raw=$rawSongCount, songsToProcess=$totalCount, isRebuild=$isRebuild"
+        )
         if (totalCount == 0) {
             Trace.endSection()
             return emptyList()

app/src/main/java/com/theveloper/pixelplay/presentation/components/UnifiedPlayerSheetV2.kt

@@ -45,6 +45,8 @@ import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
@@ -563,6 +565,14 @@ fun UnifiedPlayerSheetV2(
 
     if (!actuallyShowSheetContent) return
 
+    val playerSheetSemanticsDescription = remember(
+        currentSheetContentState,
+        infrequentPlayerState.currentSong?.title
+    ) {
+        "PixelPlay player sheet ${currentSheetContentState.name.lowercase()} " +
+            (infrequentPlayerState.currentSong?.title ?: "")
+    }
+
     Surface(
         modifier = Modifier
             .fillMaxWidth()
@@ -632,6 +642,9 @@ fun UnifiedPlayerSheetV2(
                                 shape = sheetInteractionState.playerShadowShape
                             )
                             .clipToBounds()
+                            .semantics {
+                                contentDescription = playerSheetSemanticsDescription
+                            }
                             .playerSheetVerticalDragGesture(
                                 enabled = sheetInteractionState.canDragSheet,
                                 handler = sheetInteractionState.sheetVerticalDragGestureHandler

app/src/main/java/com/theveloper/pixelplay/presentation/components/scoped/MiniPlayerDismissGestureHandler.kt

@@ -16,7 +16,9 @@ import androidx.compose.ui.hapticfeedback.HapticFeedbackType
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.unit.Density
 import androidx.compose.ui.util.lerp
+import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import kotlin.math.abs
 import kotlin.math.sign
@@ -37,11 +39,15 @@ internal class MiniPlayerDismissGestureHandler(
 ) {
     private var dragPhase: MiniDismissDragPhase = MiniDismissDragPhase.IDLE
     private var accumulatedDragX: Float = 0f
+    private var offsetJob: Job? = null
 
     fun onDragStart() {
         dragPhase = MiniDismissDragPhase.TENSION
         accumulatedDragX = 0f
-        scope.launch { offsetAnimatable.stop() }
+        offsetJob?.cancel()
+        offsetJob = scope.launch(start = CoroutineStart.UNDISPATCHED) {
+            offsetAnimatable.stop()
+        }
     }
 
     fun onHorizontalDrag(dragAmount: Float) {
@@ -54,7 +60,8 @@ internal class MiniPlayerDismissGestureHandler(
                     val maxTensionOffsetPx = 30f * density.density
                     val dragFraction = (abs(accumulatedDragX) / snapThresholdPx).coerceIn(0f, 1f)
                     val tensionOffset = lerp(0f, maxTensionOffsetPx, dragFraction)
-                    scope.launch {
+                    offsetJob?.cancel()
+                    offsetJob = scope.launch(start = CoroutineStart.UNDISPATCHED) {
                         offsetAnimatable.snapTo(tensionOffset * accumulatedDragX.sign)
                     }
                 } else {
@@ -64,7 +71,8 @@ internal class MiniPlayerDismissGestureHandler(
 
             MiniDismissDragPhase.SNAPPING -> {
                 hapticFeedback.performHapticFeedback(HapticFeedbackType.LongPress)
-                scope.launch {
+                offsetJob?.cancel()
+                offsetJob = scope.launch(start = CoroutineStart.UNDISPATCHED) {
                     offsetAnimatable.animateTo(
                         targetValue = accumulatedDragX,
                         animationSpec = spring(
@@ -77,7 +85,8 @@ internal class MiniPlayerDismissGestureHandler(
             }
 
             MiniDismissDragPhase.FREE_DRAG -> {
-                scope.launch {
+                offsetJob?.cancel()
+                offsetJob = scope.launch(start = CoroutineStart.UNDISPATCHED) {
                     offsetAnimatable.animateTo(
                         targetValue = accumulatedDragX,
                         animationSpec = spring(
@@ -94,10 +103,11 @@ internal class MiniPlayerDismissGestureHandler(
 
     fun onDragEnd() {
         dragPhase = MiniDismissDragPhase.IDLE
+        offsetJob?.cancel()
         val dismissThreshold = screenWidthPx * 0.4f
         if (abs(accumulatedDragX) > dismissThreshold) {
             val targetDismissOffset = if (accumulatedDragX < 0) -screenWidthPx else screenWidthPx
-            scope.launch {
+            offsetJob = scope.launch(start = CoroutineStart.UNDISPATCHED) {
                 offsetAnimatable.animateTo(
                     targetValue = targetDismissOffset,
                     animationSpec = tween(
@@ -109,7 +119,7 @@ internal class MiniPlayerDismissGestureHandler(
                 offsetAnimatable.snapTo(0f)
             }
         } else {
-            scope.launch {
+            offsetJob = scope.launch(start = CoroutineStart.UNDISPATCHED) {
                 offsetAnimatable.animateTo(
                     targetValue = 0f,
                     animationSpec = spring(

app/src/main/java/com/theveloper/pixelplay/presentation/components/scoped/SheetInteractionState.kt

@@ -6,7 +6,9 @@ import androidx.compose.animation.core.AnimationVector1D
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberUpdatedState
-import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.geometry.RoundRect
 import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.Outline
 import androidx.compose.ui.graphics.Shape
@@ -131,7 +133,21 @@ private class PlayerSheetDynamicShape(
     ): Outline {
         val topRadius = topRadiusProvider().nonNegative()
         val bottomRadius = bottomRadiusProvider().nonNegative()
-        val shape = if (useSmoothShapeProvider()) {
+        if (!useSmoothShapeProvider()) {
+            val topRadiusPx = with(density) { topRadius.toPx() }
+            val bottomRadiusPx = with(density) { bottomRadius.toPx() }
+            return Outline.Rounded(
+                RoundRect(
+                    rect = Rect(0f, 0f, size.width, size.height),
+                    topLeft = CornerRadius(topRadiusPx, topRadiusPx),
+                    topRight = CornerRadius(topRadiusPx, topRadiusPx),
+                    bottomRight = CornerRadius(bottomRadiusPx, bottomRadiusPx),
+                    bottomLeft = CornerRadius(bottomRadiusPx, bottomRadiusPx)
+                )
+            )
+        }
+
+        val shape =
             AbsoluteSmoothCornerShape(
                 cornerRadiusTL = topRadius,
                 smoothnessAsPercentBL = 60,
@@ -142,14 +158,6 @@ private class PlayerSheetDynamicShape(
                 cornerRadiusBL = bottomRadius,
                 smoothnessAsPercentTR = 60
             )
-        } else {
-            RoundedCornerShape(
-                topStart = topRadius,
-                topEnd = topRadius,
-                bottomStart = bottomRadius,
-                bottomEnd = bottomRadius
-            )
-        }
         return shape.createOutline(size, layoutDirection, density)
     }
 }

app/src/main/java/com/theveloper/pixelplay/presentation/components/scoped/SheetMotionController.kt

@@ -29,6 +29,15 @@ internal class SheetMotionController(
         val targetY = if (targetExpanded) expandedY else collapsedY
         val velocityScale = (collapsedY - expandedY).coerceAtLeast(1f)
 
+        if (
+            translationY.value == targetY &&
+            expansionFraction.value == targetFraction &&
+            !translationY.isRunning &&
+            !expansionFraction.isRunning
+        ) {
+            return
+        }
+
         mutex.mutate {
             coroutineScope {
                 launch {
@@ -70,6 +79,7 @@ internal class SheetMotionController(
 
     suspend fun syncToExpansion(collapsedY: Float) {
         val adjustedY = collapsedY + (expandedY - collapsedY) * expansionFraction.value
+        if (translationY.value == adjustedY && !translationY.isRunning) return
         mutex.mutate {
             translationY.snapTo(adjustedY)
         }

app/src/main/java/com/theveloper/pixelplay/presentation/components/scoped/SheetVerticalDragGestureHandler.kt

@@ -13,7 +13,9 @@ import androidx.compose.ui.input.pointer.util.VelocityTracker
 import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.dp
 import com.theveloper.pixelplay.presentation.viewmodel.PlayerSheetState
+import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 
 /**
@@ -45,9 +47,13 @@ internal class SheetVerticalDragGestureHandler(
     private var initialFractionOnDragStart = 0f
     private var initialYOnDragStart = 0f
     private var accumulatedDragYSinceStart = 0f
+    private var dragSnapJob: Job? = null
 
     fun onDragStart() {
-        scope.launch { sheetMotionController.stop() }
+        dragSnapJob?.cancel()
+        dragSnapJob = scope.launch(start = CoroutineStart.UNDISPATCHED) {
+            sheetMotionController.stop()
+        }
         onDraggingChange(true)
         onDraggingPlayerAreaChange(true)
         velocityTracker.resetTracking()
@@ -62,16 +68,17 @@ internal class SheetVerticalDragGestureHandler(
         dragAmount: Float
     ) {
         accumulatedDragYSinceStart += dragAmount
-        scope.launch {
-            val dragFrame = computeSheetVerticalDragFrame(
-                currentTranslationY = currentSheetTranslationY.value,
-                dragAmount = dragAmount,
-                expandedY = expandedYProvider(),
-                collapsedY = collapsedYProvider(),
-                miniHeightPx = miniHeightPxProvider(),
-                initialFractionOnDragStart = initialFractionOnDragStart,
-                initialYOnDragStart = initialYOnDragStart
-            )
+        val dragFrame = computeSheetVerticalDragFrame(
+            currentTranslationY = currentSheetTranslationY.value,
+            dragAmount = dragAmount,
+            expandedY = expandedYProvider(),
+            collapsedY = collapsedYProvider(),
+            miniHeightPx = miniHeightPxProvider(),
+            initialFractionOnDragStart = initialFractionOnDragStart,
+            initialYOnDragStart = initialYOnDragStart
+        )
+        dragSnapJob?.cancel()
+        dragSnapJob = scope.launch(start = CoroutineStart.UNDISPATCHED) {
             sheetMotionController.snapTo(
                 translationYValue = dragFrame.translationY,
                 expansionFractionValue = dragFrame.expansionFraction
@@ -81,6 +88,8 @@ internal class SheetVerticalDragGestureHandler(
     }
 
     fun onDragEnd() {
+        dragSnapJob?.cancel()
+        dragSnapJob = null
         onDraggingChange(false)
         onDraggingPlayerAreaChange(false)
 

app/src/main/java/com/theveloper/pixelplay/presentation/components/scoped/SheetVisualState.kt

@@ -6,6 +6,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
@@ -87,13 +88,15 @@ internal fun rememberSheetVisualState(
     // Lambda provider: read inside .offset { } block (layout phase) — avoids recomposition
     // at ~60fps during drag gestures. The lambda captures Animatable refs and reads them at
     // layout time, same pattern as the horizontal padding providers above.
+    val predictiveBackCollapseProgressState = rememberUpdatedState(predictiveBackCollapseProgress)
     val visualSheetTranslationYProvider: () -> Float = remember(
         currentSheetTranslationY,
         sheetCollapsedTargetY
     ) {
         {
-            currentSheetTranslationY.value * (1f - predictiveBackCollapseProgress) +
-                (sheetCollapsedTargetY * predictiveBackCollapseProgress)
+            val progress = predictiveBackCollapseProgressState.value
+            currentSheetTranslationY.value * (1f - progress) +
+                (sheetCollapsedTargetY * progress)
         }
     }
 

app/src/main/java/com/theveloper/pixelplay/presentation/viewmodel/PlayerViewModel.kt

@@ -4809,6 +4809,30 @@ class PlayerViewModel @Inject constructor(
         }
     }
 
+    fun prepareBenchmarkPlayerFromLibrary() {
+        viewModelScope.launch {
+            repeat(90) { attempt ->
+                val controllerReady = mediaController != null
+                val songs = withContext(Dispatchers.IO) {
+                    musicRepository.getAllSongsOnce()
+                }
+                Log.i(
+                    "PixelPlayBenchmark",
+                    "prepare player attempt=$attempt controllerReady=$controllerReady songs=${songs.size}"
+                )
+                if (controllerReady && songs.isNotEmpty()) {
+                    playSongs(songs, songs.first(), "Benchmark Player")
+                    delay(700L)
+                    collapsePlayerSheet()
+                    Log.i("PixelPlayBenchmark", "Benchmark player prepared with ${songs.first().title}")
+                    return@launch
+                }
+                delay(500L)
+            }
+            Log.w("PixelPlayBenchmark", "Unable to prepare benchmark player from library")
+        }
+    }
+
     private var pendingBatchGenreEdit: Pair<List<Song>, String>? = null
 
     fun batchEditGenre(songs: List<Song>, newGenre: String) {

baselineprofile/src/main/java/com/theveloper/pixelplay/baselineprofile/BenchmarkEnvironment.kt

@@ -37,6 +37,9 @@ internal fun MacrobenchmarkScope.setupBenchmarkPermissions(packageName: String =
     }
 }
 
+internal fun MacrobenchmarkScope.executeBenchmarkShellCommand(command: String): String =
+    executeShellCommandSafely(command)
+
 internal fun MacrobenchmarkScope.waitForAppForeground(
     context: String,
     packageName: String = benchmarkTargetPackageName(),
@@ -103,7 +106,7 @@ private fun requiredRuntimePermissions(): List<String> = buildList {
 
 private fun MacrobenchmarkScope.executeShellCommandSafely(command: String): String =
     try {
-        device.executeShellCommand("$command 2>&1").orEmpty()
+        device.executeShellCommand(command).orEmpty()
     } catch (exception: Exception) {
         Log.w(TAG, "Ignoring shell failure for: $command", exception)
         exception.message.orEmpty()