revert the library header colour and gradient

app/src/main/kotlin/com/subtracks/ui/AppRoot.kt

@@ -21,7 +21,6 @@ import androidx.compose.foundation.layout.consumeWindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.navigationBars
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
@@ -56,7 +55,6 @@ import com.subtracks.ui.playback.NowPlayingRoute
 import com.subtracks.ui.playback.QueueRoute
 import com.subtracks.ui.settings.AddSourceRoute
 import com.subtracks.ui.settings.SettingsRoute
-import com.subtracks.ui.theme.LocalPlayerArtwork
 import com.subtracks.ui.theme.rememberArtworkColors
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.SharingStarted
@@ -145,180 +143,176 @@ private fun MainNavigation() {
             nowPlayingProgress = 0f
         }
     }
-    val miniArt = playbackController.coverArt(playback.item, thumbnail = true)
-    val miniArtwork = rememberArtworkColors(miniArt)
-    val libraryArtwork = miniArtwork.takeIf { miniArt != null }
     val density = LocalDensity.current
     val navBarInset = with(density) { WindowInsets.navigationBars.getBottom(this).toDp() }
 
-    CompositionLocalProvider(LocalPlayerArtwork provides libraryArtwork) {
+    Box(Modifier.fillMaxSize()) {
-        Box(Modifier.fillMaxSize()) {
+        Column(Modifier.fillMaxSize()) {
-            Column(Modifier.fillMaxSize()) {
+            NavHost(
-                NavHost(
+                navController = navController,
-                    navController = navController,
+                modifier =
-                    modifier =
+                    Modifier
-                        Modifier
+                        .weight(1f)
-                            .weight(1f)
+                        .then(
-                            .then(
+                            if (playerVisible) {
-                                if (playerVisible) {
+                                Modifier.consumeWindowInsets(WindowInsets.navigationBars)
-                                    Modifier.consumeWindowInsets(WindowInsets.navigationBars)
+                            } else {
-                                } else {
+                                Modifier
-                                    Modifier
+                            },
-                                },
+                        ),
-                            ),
+                startDestination = Routes.LIBRARY,
-                    startDestination = Routes.LIBRARY,
+                enterTransition = {
-                    enterTransition = {
+                    slideInHorizontally(initialOffsetX = { it / 4 }, animationSpec = tween(NAVIGATION_DURATION_MS)) +
-                        slideInHorizontally(initialOffsetX = { it / 4 }, animationSpec = tween(NAVIGATION_DURATION_MS)) +
+                        fadeIn(tween(NAVIGATION_DURATION_MS))
-                            fadeIn(tween(NAVIGATION_DURATION_MS))
+                },
-                    },
+                exitTransition = {
-                    exitTransition = {
+                    slideOutHorizontally(targetOffsetX = { -it / 4 }, animationSpec = tween(NAVIGATION_DURATION_MS)) +
-                        slideOutHorizontally(targetOffsetX = { -it / 4 }, animationSpec = tween(NAVIGATION_DURATION_MS)) +
+                        fadeOut(tween(NAVIGATION_DURATION_MS))
-                            fadeOut(tween(NAVIGATION_DURATION_MS))
+                },
-                    },
+                popEnterTransition = {
-                    popEnterTransition = {
+                    slideInHorizontally(initialOffsetX = { -it / 4 }, animationSpec = tween(NAVIGATION_DURATION_MS)) +
-                        slideInHorizontally(initialOffsetX = { -it / 4 }, animationSpec = tween(NAVIGATION_DURATION_MS)) +
+                        fadeIn(tween(NAVIGATION_DURATION_MS))
-                            fadeIn(tween(NAVIGATION_DURATION_MS))
+                },
-                    },
+                popExitTransition = {
-                    popExitTransition = {
+                    slideOutHorizontally(targetOffsetX = { it / 4 }, animationSpec = tween(NAVIGATION_DURATION_MS)) +
-                        slideOutHorizontally(targetOffsetX = { it / 4 }, animationSpec = tween(NAVIGATION_DURATION_MS)) +
+                        fadeOut(tween(NAVIGATION_DURATION_MS))
-                            fadeOut(tween(NAVIGATION_DURATION_MS))
+                },
-                    },
-                ) {
-                    composable(Routes.LIBRARY) {
-                        LibraryRoute(
-                            onAlbumClick = { album -> navController.navigate(Routes.album(album.id, album.coverArt)) },
-                            onArtistClick = { artist -> navController.navigate(Routes.artist(artist.id, artist.coverArt)) },
-                            onPlaylistClick = { playlist -> navController.navigate(Routes.playlist(playlist.id)) },
-                            onOpenSettings = { navController.navigate(Routes.SETTINGS) },
-                            bottomInset = if (playerVisible) 0.dp else navBarInset,
-                        )
-                    }
-                    composable(Routes.SETTINGS) {
-                        SettingsRoute(
-                            onAddServer = { navController.navigate(Routes.ADD_SERVER) },
-                            onBack = { navController.popBackStack() },
-                        )
-                    }
-                    composable(
-                        route = Routes.ALBUM_DETAIL,
-                        arguments =
-                            listOf(
-                                navArgument("albumId") { type = NavType.StringType },
-                                navArgument("coverArt") {
-                                    type = NavType.StringType
-                                    defaultValue = ""
-                                },
-                            ),
-                    ) { entry ->
-                        AlbumDetailRoute(
-                            albumId = entry.arguments?.getString("albumId").orEmpty(),
-                            coverArtId =
-                                entry.arguments
-                                    ?.getString("coverArt")
-                                    .orEmpty()
-                                    .ifEmpty { null },
-                            onBack = { navController.popBackStack() },
-                        )
-                    }
-                    composable(
-                        route = Routes.ARTIST_DETAIL,
-                        arguments =
-                            listOf(
-                                navArgument("artistId") { type = NavType.StringType },
-                                navArgument("coverArt") {
-                                    type = NavType.StringType
-                                    defaultValue = ""
-                                },
-                            ),
-                    ) { entry ->
-                        ArtistDetailRoute(
-                            artistId = entry.arguments?.getString("artistId").orEmpty(),
-                            coverArtId =
-                                entry.arguments
-                                    ?.getString("coverArt")
-                                    .orEmpty()
-                                    .ifEmpty { null },
-                            onBack = { navController.popBackStack() },
-                            onAlbumClick = { album -> navController.navigate(Routes.album(album.id, album.coverArt)) },
-                        )
-                    }
-                    composable(
-                        route = Routes.PLAYLIST_DETAIL,
-                        arguments = listOf(navArgument("playlistId") { type = NavType.StringType }),
-                    ) { entry ->
-                        PlaylistDetailRoute(
-                            playlistId = entry.arguments?.getString("playlistId").orEmpty(),
-                            onBack = { navController.popBackStack() },
-                        )
-                    }
-                    composable(Routes.ADD_SERVER) {
-                        AddSourceRoute(
-                            onSaved = { navController.popBackStack() },
-                            onBack = { navController.popBackStack() },
-                        )
-                    }
-                }
-
-                if (playerVisible) {
-                    MiniPlayer(
-                        state = playback,
-                        coverArt = miniArt,
-                        artwork = miniArtwork,
-                        onExpand = { settleNowPlaying(true) },
-                        onPlayPause = playbackController::togglePlayPause,
-                        onNext = playbackController::next,
-                        onExpandDrag = { dragUpPx ->
-                            nowPlayingOpen = true
-                            settleJob?.cancel()
-                            if (miniPlayerTopPx > 0f) {
-                                nowPlayingProgress = (dragUpPx / miniPlayerTopPx).coerceIn(0f, 1f)
-                            }
-                        },
-                        onExpandRelease = { velocity -> settleNowPlaying(nowPlayingProgress > 0.05f || velocity < -FLING_VELOCITY) },
-                        modifier = Modifier.onGloballyPositioned { miniPlayerTopPx = it.positionInRoot().y },
-                    )
-                }
-            }
-
-            if (nowPlayingOpen) {
-                Box(
-                    modifier =
-                        Modifier
-                            .fillMaxSize()
-                            .graphicsLayer {
-                                translationY = (1f - nowPlayingProgress) * miniPlayerTopPx
-                                alpha = (nowPlayingProgress / EXPAND_FADE).coerceAtMost(1f)
-                            }.draggable(
-                                orientation = Orientation.Vertical,
-                                state =
-                                    rememberDraggableState { delta ->
-                                        settleJob?.cancel()
-                                        if (miniPlayerTopPx > 0f) {
-                                            nowPlayingProgress = (nowPlayingProgress - delta / miniPlayerTopPx).coerceIn(0f, 1f)
-                                        }
-                                    },
-                                onDragStopped = { velocity -> settleNowPlaying(nowPlayingProgress > 0.9f && velocity < FLING_VELOCITY) },
-                            ),
-                ) {
-                    NowPlayingRoute(
-                        onBack = { settleNowPlaying(false) },
-                        onQueue = { showingQueue = true },
-                        modifier = Modifier.fillMaxSize(),
-                    )
-                }
-            }
-
-            AnimatedVisibility(
-                visible = showingQueue,
-                enter = slideInVertically(initialOffsetY = { it }) + fadeIn(tween(OVERLAY_DURATION_MS)),
-                exit = slideOutVertically(targetOffsetY = { it }) + fadeOut(tween(OVERLAY_DURATION_MS)),
             ) {
-                QueueRoute(
+                composable(Routes.LIBRARY) {
-                    onBack = { showingQueue = false },
+                    LibraryRoute(
+                        onAlbumClick = { album -> navController.navigate(Routes.album(album.id, album.coverArt)) },
+                        onArtistClick = { artist -> navController.navigate(Routes.artist(artist.id, artist.coverArt)) },
+                        onPlaylistClick = { playlist -> navController.navigate(Routes.playlist(playlist.id)) },
+                        onOpenSettings = { navController.navigate(Routes.SETTINGS) },
+                        bottomInset = if (playerVisible) 0.dp else navBarInset,
+                    )
+                }
+                composable(Routes.SETTINGS) {
+                    SettingsRoute(
+                        onAddServer = { navController.navigate(Routes.ADD_SERVER) },
+                        onBack = { navController.popBackStack() },
+                    )
+                }
+                composable(
+                    route = Routes.ALBUM_DETAIL,
+                    arguments =
+                        listOf(
+                            navArgument("albumId") { type = NavType.StringType },
+                            navArgument("coverArt") {
+                                type = NavType.StringType
+                                defaultValue = ""
+                            },
+                        ),
+                ) { entry ->
+                    AlbumDetailRoute(
+                        albumId = entry.arguments?.getString("albumId").orEmpty(),
+                        coverArtId =
+                            entry.arguments
+                                ?.getString("coverArt")
+                                .orEmpty()
+                                .ifEmpty { null },
+                        onBack = { navController.popBackStack() },
+                    )
+                }
+                composable(
+                    route = Routes.ARTIST_DETAIL,
+                    arguments =
+                        listOf(
+                            navArgument("artistId") { type = NavType.StringType },
+                            navArgument("coverArt") {
+                                type = NavType.StringType
+                                defaultValue = ""
+                            },
+                        ),
+                ) { entry ->
+                    ArtistDetailRoute(
+                        artistId = entry.arguments?.getString("artistId").orEmpty(),
+                        coverArtId =
+                            entry.arguments
+                                ?.getString("coverArt")
+                                .orEmpty()
+                                .ifEmpty { null },
+                        onBack = { navController.popBackStack() },
+                        onAlbumClick = { album -> navController.navigate(Routes.album(album.id, album.coverArt)) },
+                    )
+                }
+                composable(
+                    route = Routes.PLAYLIST_DETAIL,
+                    arguments = listOf(navArgument("playlistId") { type = NavType.StringType }),
+                ) { entry ->
+                    PlaylistDetailRoute(
+                        playlistId = entry.arguments?.getString("playlistId").orEmpty(),
+                        onBack = { navController.popBackStack() },
+                    )
+                }
+                composable(Routes.ADD_SERVER) {
+                    AddSourceRoute(
+                        onSaved = { navController.popBackStack() },
+                        onBack = { navController.popBackStack() },
+                    )
+                }
+            }
+
+            if (playerVisible) {
+                val miniArt = playbackController.coverArt(playback.item, thumbnail = true)
+                MiniPlayer(
+                    state = playback,
+                    coverArt = miniArt,
+                    artwork = rememberArtworkColors(miniArt),
+                    onExpand = { settleNowPlaying(true) },
+                    onPlayPause = playbackController::togglePlayPause,
+                    onNext = playbackController::next,
+                    onExpandDrag = { dragUpPx ->
+                        nowPlayingOpen = true
+                        settleJob?.cancel()
+                        if (miniPlayerTopPx > 0f) {
+                            nowPlayingProgress = (dragUpPx / miniPlayerTopPx).coerceIn(0f, 1f)
+                        }
+                    },
+                    onExpandRelease = { velocity -> settleNowPlaying(nowPlayingProgress > 0.05f || velocity < -FLING_VELOCITY) },
+                    modifier = Modifier.onGloballyPositioned { miniPlayerTopPx = it.positionInRoot().y },
+                )
+            }
+        }
+
+        if (nowPlayingOpen) {
+            Box(
+                modifier =
+                    Modifier
+                        .fillMaxSize()
+                        .graphicsLayer {
+                            translationY = (1f - nowPlayingProgress) * miniPlayerTopPx
+                            alpha = (nowPlayingProgress / EXPAND_FADE).coerceAtMost(1f)
+                        }.draggable(
+                            orientation = Orientation.Vertical,
+                            state =
+                                rememberDraggableState { delta ->
+                                    settleJob?.cancel()
+                                    if (miniPlayerTopPx > 0f) {
+                                        nowPlayingProgress = (nowPlayingProgress - delta / miniPlayerTopPx).coerceIn(0f, 1f)
+                                    }
+                                },
+                            onDragStopped = { velocity -> settleNowPlaying(nowPlayingProgress > 0.9f && velocity < FLING_VELOCITY) },
+                        ),
+            ) {
+                NowPlayingRoute(
+                    onBack = { settleNowPlaying(false) },
+                    onQueue = { showingQueue = true },
                     modifier = Modifier.fillMaxSize(),
                 )
             }
         }
+
+        AnimatedVisibility(
+            visible = showingQueue,
+            enter = slideInVertically(initialOffsetY = { it }) + fadeIn(tween(OVERLAY_DURATION_MS)),
+            exit = slideOutVertically(targetOffsetY = { it }) + fadeOut(tween(OVERLAY_DURATION_MS)),
+        ) {
+            QueueRoute(
+                onBack = { showingQueue = false },
+                modifier = Modifier.fillMaxSize(),
+            )
+        }
     }
 
     BackHandler(enabled = showingQueue) { showingQueue = false }

app/src/main/kotlin/com/subtracks/ui/library/LibraryScreen.kt

@@ -4,7 +4,6 @@ import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
@@ -40,9 +39,7 @@ import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.SideEffect
-import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableStateMapOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -53,16 +50,9 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
-import androidx.compose.ui.draw.drawBehind
-import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.geometry.Rect
-import androidx.compose.ui.graphics.Brush
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.graphics.lerp
 import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
-import androidx.compose.ui.input.nestedscroll.NestedScrollSource
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.layout.boundsInParent
 import androidx.compose.ui.layout.onGloballyPositioned
@@ -78,9 +68,6 @@ import com.subtracks.data.model.Artist
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.Playlist
 import com.subtracks.data.model.SongListItem
-import com.subtracks.ui.theme.HeroGradient
-import com.subtracks.ui.theme.LocalPlayerArtwork
-import com.subtracks.ui.theme.heroBarColor
 import org.koin.compose.viewmodel.koinViewModel
 import kotlin.math.abs
 import kotlin.math.roundToInt
@@ -179,107 +166,58 @@ fun LibraryScreen(
     SideEffect { scrollBehavior.state.heightOffsetLimit = -with(density) { titleHeight.toPx() } }
     val titleFraction = scrollBehavior.state.collapsedFraction
 
-    var scrollPx by remember { mutableFloatStateOf(0f) }
+    val statusBarTop = with(density) { WindowInsets.statusBars.getTop(this).toDp() }
-    val scrollTracker =
-        remember {
-            object : NestedScrollConnection {
-                override fun onPostScroll(
-                    consumed: Offset,
-                    available: Offset,
-                    source: NestedScrollSource,
-                ): Offset {
-                    scrollPx = (scrollPx - consumed.y).coerceAtLeast(0f)
-                    return Offset.Zero
-                }
-            }
-        }
 
-    val artwork = LocalPlayerArtwork.current
+    Column(
-    val statusBarTopPx = WindowInsets.statusBars.getTop(density)
-    val statusBarTop = with(density) { statusBarTopPx.toDp() }
-
-    BoxWithConstraints(
         modifier =
             modifier
                 .fillMaxSize()
                 .background(MaterialTheme.colorScheme.background)
-                .nestedScroll(scrollTracker)
                 .nestedScroll(scrollBehavior.nestedScrollConnection),
     ) {
-        val screenHeightPx = with(density) { maxHeight.toPx() }
+        Column(
-        val barHeightPx = statusBarTopPx + with(density) { TopAppBarDefaults.TopAppBarExpandedHeight.toPx() }
-        val selectedColor = heroBarColor(artwork, 0f, barHeightPx, screenHeightPx)
-        val barColor by
-            remember(artwork, barHeightPx, screenHeightPx) {
-                derivedStateOf { heroBarColor(artwork, scrollPx, barHeightPx, screenHeightPx) }
-            }
-
-        HeroGradient(
-            colors = artwork,
-            scrollPx = { scrollPx },
-            modifier = Modifier.fillMaxSize(),
-        )
-
-        Box(
             modifier =
                 Modifier
-                    .align(Alignment.TopStart)
                     .fillMaxWidth()
-                    .height(statusBarTop + 8.dp)
+                    .padding(top = statusBarTop),
-                    .background(
+        ) {
-                        Brush.verticalGradient(
+            Box(
-                            listOf(Color.Black.copy(alpha = 0.55f), Color.Transparent),
-                        ),
-                    ).graphicsLayer { alpha = 1f - titleFraction },
-        )
-
-        Column(Modifier.fillMaxSize()) {
-            Column(
                 modifier =
                     Modifier
                         .fillMaxWidth()
-                        .drawBehind { drawRect(barColor.copy(alpha = titleFraction)) }
+                        .height(titleHeight * (1f - titleFraction))
-                        .padding(top = statusBarTop),
+                        .clipToBounds(),
             ) {
-                Box(
+                Text(
+                    text = selectedTab.label,
+                    style = MaterialTheme.typography.headlineLarge,
+                    color = MaterialTheme.colorScheme.onBackground,
+                    maxLines = 1,
                     modifier =
                         Modifier
-                            .fillMaxWidth()
+                            .offset(y = -(titleHeight * titleFraction))
-                            .height(titleHeight * (1f - titleFraction))
+                            .wrapContentHeight(unbounded = true)
-                            .clipToBounds(),
+                            .padding(start = 8.dp, end = 16.dp, top = titleTop),
-                ) {
-                    Text(
-                        text = selectedTab.label,
-                        style = MaterialTheme.typography.headlineLarge,
-                        color = MaterialTheme.colorScheme.onBackground,
-                        maxLines = 1,
-                        modifier =
-                            Modifier
-                                .offset(y = -(titleHeight * titleFraction))
-                                .wrapContentHeight(unbounded = true)
-                                .padding(start = 8.dp, end = 16.dp, top = titleTop),
-                    )
-                }
-                LibraryTabs(
-                    pagerState = pagerState,
-                    onTabSelected = onTabSelected,
-                    syncing = syncing,
-                    onSync = onSync,
-                    onOpenSettings = onOpenSettings,
-                    selectedColor = selectedColor,
                 )
             }
+            LibraryTabs(
+                pagerState = pagerState,
+                onTabSelected = onTabSelected,
+                syncing = syncing,
+                onSync = onSync,
+                onOpenSettings = onOpenSettings,
+            )
+        }
 
-            HorizontalPager(
+        HorizontalPager(
-                state = pagerState,
+            state = pagerState,
-                modifier = Modifier.fillMaxWidth().weight(1f),
+            modifier = Modifier.fillMaxWidth().weight(1f),
-            ) { page ->
+        ) { page ->
-                when (LibraryTab.entries[page]) {
+            when (LibraryTab.entries[page]) {
-                    LibraryTab.Albums -> AlbumsContent(albums, coverArt, bottomInset, onAlbumClick)
+                LibraryTab.Albums -> AlbumsContent(albums, coverArt, bottomInset, onAlbumClick)
-                    LibraryTab.Artists -> ArtistsContent(artists, coverArt, bottomInset, onArtistClick)
+                LibraryTab.Artists -> ArtistsContent(artists, coverArt, bottomInset, onArtistClick)
-                    LibraryTab.Songs -> SongsContent(songs, coverArt, bottomInset, onSongClick, playingSongId)
+                LibraryTab.Songs -> SongsContent(songs, coverArt, bottomInset, onSongClick, playingSongId)
-                    LibraryTab.Playlists -> PlaylistsContent(playlists, coverArt, bottomInset, onPlaylistClick)
+                LibraryTab.Playlists -> PlaylistsContent(playlists, coverArt, bottomInset, onPlaylistClick)
-                }
             }
         }
     }
@@ -293,7 +231,6 @@ private fun LibraryTabs(
     syncing: Boolean,
     onSync: () -> Unit,
     onOpenSettings: () -> Unit,
-    selectedColor: Color,
 ) {
     val iconFadeThreshold = 0.65f
     val indicatorStretch = 18.dp
@@ -337,7 +274,6 @@ private fun LibraryTabs(
                         ((iconFadeThreshold - abs(position - index)) / iconFadeThreshold)
                             .coerceIn(0f, 1f),
                     onClick = { onTabSelected(tab) },
-                    selectedColor = selectedColor,
                     modifier =
                         Modifier.onGloballyPositioned { coordinates ->
                             bounds[index] = coordinates.boundsInParent()
@@ -375,10 +311,9 @@ private fun TabButton(
     tab: LibraryTab,
     progress: Float,
     onClick: () -> Unit,
-    selectedColor: Color,
     modifier: Modifier = Modifier,
 ) {
-    val content = lerp(MaterialTheme.colorScheme.onBackground, selectedColor, progress)
+    val content = lerp(MaterialTheme.colorScheme.onBackground, MaterialTheme.colorScheme.background, progress)
     Box(
         modifier =
             modifier

app/src/main/kotlin/com/subtracks/ui/theme/ArtworkTheme.kt

@@ -7,7 +7,6 @@ import androidx.compose.material3.darkColorScheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.State
-import androidx.compose.runtime.compositionLocalOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.produceState
 import androidx.compose.runtime.remember
@@ -206,8 +205,6 @@ fun ArtworkTheme(
     }
 }
 
-val LocalPlayerArtwork = compositionLocalOf<ArtworkColors?> { null }
-
 fun playerSurfaceColor(artwork: ArtworkColors): Color = lerp(artwork.scheme.surfaceContainerHigh, artwork.gradientHigh, 0.5f)
 
 fun heroBarColor(

app/src/test/kotlin/com/subtracks/ui/AppScreenshotTest.kt

@@ -9,7 +9,6 @@ import androidx.activity.ComponentActivity
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
@@ -50,7 +49,6 @@ import com.subtracks.ui.playback.QueueScreen
 import com.subtracks.ui.settings.AddSourceScreen
 import com.subtracks.ui.settings.AddSourceState
 import com.subtracks.ui.settings.SettingsScreen
-import com.subtracks.ui.theme.LocalPlayerArtwork
 import com.subtracks.ui.theme.SubtracksTheme
 import com.subtracks.ui.theme.artworkColorsFromSeed
 import com.subtracks.ui.theme.artworkColorsFromSeeds
@@ -329,23 +327,21 @@ class AppScreenshotTest {
     private fun setLibraryContent(tab: LibraryTab) {
         composeRule.setContent {
             SubtracksTheme {
-                CompositionLocalProvider(LocalPlayerArtwork provides artworkColorsFromSeed(Color.rgb(120, 80, 200))) {
+                LibraryScreen(
-                    LibraryScreen(
+                    selectedTab = tab,
-                        selectedTab = tab,
+                    onTabSelected = {},
-                        onTabSelected = {},
+                    albums = remember { flowOf(PagingData.from(Fixtures.albums)) }.collectAsLazyPagingItems(),
-                        albums = remember { flowOf(PagingData.from(Fixtures.albums)) }.collectAsLazyPagingItems(),
+                    artists = remember { flowOf(PagingData.from(Fixtures.artists)) }.collectAsLazyPagingItems(),
-                        artists = remember { flowOf(PagingData.from(Fixtures.artists)) }.collectAsLazyPagingItems(),
+                    songs = remember { flowOf(PagingData.from(Fixtures.songItems)) }.collectAsLazyPagingItems(),
-                        songs = remember { flowOf(PagingData.from(Fixtures.songItems)) }.collectAsLazyPagingItems(),
+                    playlists = remember { flowOf(PagingData.from(Fixtures.playlists)) }.collectAsLazyPagingItems(),
-                        playlists = remember { flowOf(PagingData.from(Fixtures.playlists)) }.collectAsLazyPagingItems(),
+                    coverArt = { id, _ -> id?.let { CoverArtRef(it, "test:$it") } },
-                        coverArt = { id, _ -> id?.let { CoverArtRef(it, "test:$it") } },
+                    onAlbumClick = {},
-                        onAlbumClick = {},
+                    onArtistClick = {},
-                        onArtistClick = {},
+                    onPlaylistClick = {},
-                        onPlaylistClick = {},
+                    onSongClick = {},
-                        onSongClick = {},
+                    onSync = {},
-                        onSync = {},
+                    onOpenSettings = {},
-                        onOpenSettings = {},
+                )
-                    )
-                }
             }
         }
     }