commit-15bf160.diff

diff --git a/app/src/main/kotlin/com/metrolist/music/App.kt b/app/src/main/kotlin/com/metrolist/music/App.kt
index 34a3db32fc..b990b78f24 100644
--- a/app/src/main/kotlin/com/metrolist/music/App.kt
+++ b/app/src/main/kotlin/com/metrolist/music/App.kt
@@ -82,6 +82,11 @@ class App :
 
         Timber.plant(Timber.DebugTree())
 
+        // Pre-read Coil cache size on background to avoid runBlocking in newImageLoader
+        applicationScope.launch(Dispatchers.IO) {
+            cachedCoilCacheSize = dataStore.data.map { it[MaxImageCacheSizeKey] ?: 512 }.first()
+        }
+
         // تهيئة إعدادات التطبيق عند الإقلاع
         applicationScope.launch {
             initializeSettings()
@@ -250,11 +255,13 @@ class App :
         }
     }
 
+    @Volatile
+    private var cachedCoilCacheSize: Int? = null
+
     override fun newImageLoader(context: PlatformContext): ImageLoader {
-        val cacheSize =
-            runBlocking {
-                dataStore.data.map { it[MaxImageCacheSizeKey] ?: 512 }.first()
-            }
+        val cacheSize = cachedCoilCacheSize ?: runBlocking {
+            dataStore.data.map { it[MaxImageCacheSizeKey] ?: 512 }.first()
+        }
         return ImageLoader
             .Builder(this)
             .apply {
@@ -264,7 +271,7 @@ class App :
                 memoryCache {
                     MemoryCache
                         .Builder()
-                        .maxSizePercent(context, 0.25)
+                        .maxSizePercent(context, 0.15)
                         .build()
                 }
                 if (cacheSize == 0) {
diff --git a/app/src/main/kotlin/com/metrolist/music/MainActivity.kt b/app/src/main/kotlin/com/metrolist/music/MainActivity.kt
index 9b9094432b..7bff7f693d 100644
--- a/app/src/main/kotlin/com/metrolist/music/MainActivity.kt
+++ b/app/src/main/kotlin/com/metrolist/music/MainActivity.kt
@@ -77,6 +77,7 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.runtime.withFrameNanos
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -409,6 +410,43 @@ class MainActivity : ComponentActivity() {
                 }
         }
 
+        // Defer migration and version tracking to avoid blocking first frame
+        lifecycleScope.launch(Dispatchers.IO) {
+            val preferences = dataStore.data.first()
+            val currentVersion = BuildConfig.VERSION_NAME
+
+            // SimpMusic Removal Migration
+            if (preferences[SimpMusicMigrationDoneKey] != true) {
+                dataStore.edit { settings ->
+                    val currentOrder = settings[LyricsProviderOrderKey] ?: ""
+                    if (currentOrder.contains("SimpMusic")) {
+                        val orderList =
+                            currentOrder
+                                .split(",")
+                                .map { it.trim() }
+                                .filter { it.isNotBlank() && it != "SimpMusic" }
+                                .toMutableList()
+                        if (orderList.isEmpty()) {
+                            settings[LyricsProviderOrderKey] = ""
+                        } else {
+                            settings[LyricsProviderOrderKey] = orderList.joinToString(",")
+                        }
+                    }
+                    if (settings[PreferredLyricsProviderKey] == "SIMPMUSIC") {
+                        settings[PreferredLyricsProviderKey] = PreferredLyricsProvider.LRCLIB.name
+                    }
+                    settings[SimpMusicMigrationDoneKey] = true
+                    settings[LastSeenVersionKey] = currentVersion
+                }
+            }
+        }
+
+        lifecycleScope.launch(Dispatchers.IO) {
+            dataStore.edit { settings ->
+                settings[LastSeenVersionKey] = BuildConfig.VERSION_NAME
+            }
+        }
+
         setContent {
             MetrolistApp(
                 latestVersionName = latestVersionName,
@@ -539,6 +577,8 @@ class MainActivity : ComponentActivity() {
             mutableStateOf(selectedThemeColor)
         }
 
+        val themeColorCache = remember { mutableMapOf<String, Color>() }
+
         LaunchedEffect(selectedThemeColor) {
             if (!enableDynamicTheme) {
                 themeColor = selectedThemeColor
@@ -552,32 +592,43 @@ class MainActivity : ComponentActivity() {
                 return@LaunchedEffect
             }
 
-            playerConnection.service.currentMediaMetadata.collectLatest { song ->
-                if (song?.thumbnailUrl != null) {
-                    withContext(Dispatchers.IO) {
-                        try {
-                            val result =
-                                imageLoader.execute(
-                                    ImageRequest
-                                        .Builder(this@MainActivity)
-                                        .data(song.thumbnailUrl)
-                                        .allowHardware(false)
-                                        .memoryCachePolicy(CachePolicy.ENABLED)
-                                        .diskCachePolicy(CachePolicy.ENABLED)
-                                        .networkCachePolicy(CachePolicy.ENABLED)
-                                        .crossfade(false)
-                                        .build(),
-                                )
-                            themeColor = result.image?.toBitmap()?.extractThemeColor() ?: selectedThemeColor
-                        } catch (e: Exception) {
-                            // Fallback to default on error
-                            themeColor = selectedThemeColor
+            playerConnection.service.currentMediaMetadata
+                .distinctUntilChanged { old, new -> old?.id == new?.id }
+                .collectLatest { song ->
+                    if (song?.thumbnailUrl != null) {
+                        val cached = themeColorCache[song.thumbnailUrl]
+                        if (cached != null) {
+                            withFrameNanos { }
+                            themeColor = cached
+                            return@collectLatest
                         }
+                        withContext(Dispatchers.IO) {
+                            try {
+                                val result =
+                                    imageLoader.execute(
+                                        ImageRequest
+                                            .Builder(this@MainActivity)
+                                            .data(song.thumbnailUrl)
+                                            .allowHardware(false)
+                                            .memoryCachePolicy(CachePolicy.ENABLED)
+                                            .diskCachePolicy(CachePolicy.ENABLED)
+                                            .networkCachePolicy(CachePolicy.ENABLED)
+                                            .crossfade(false)
+                                            .build(),
+                                    )
+                                val extractedColor = result.image?.toBitmap()?.extractThemeColor() ?: selectedThemeColor
+                                themeColorCache[song.thumbnailUrl] = extractedColor
+                                withFrameNanos { }
+                                themeColor = extractedColor
+                            } catch (e: Exception) {
+                                withFrameNanos { }
+                                themeColor = selectedThemeColor
+                            }
+                        }
+                    } else {
+                        themeColor = selectedThemeColor
                     }
-                } else {
-                    themeColor = selectedThemeColor
                 }
-            }
         }
 
         MetrolistTheme(
@@ -606,40 +657,6 @@ class MainActivity : ComponentActivity() {
                     if (lastSeenVersion != currentVersion) {
                         showChangelog.value = true
                     }
-
-                    // SimpMusic Removal Migration
-                    if (dataStore.data.first()[SimpMusicMigrationDoneKey] != true) {
-                        dataStore.edit { settings ->
-                            val currentOrder = settings[LyricsProviderOrderKey] ?: ""
-                            if (currentOrder.contains("SimpMusic")) {
-                                // If the old order only contained SimpMusic, reset to default order
-                                // Otherwise remove SimpMusic and keep the rest
-                                val orderList =
-                                    currentOrder
-                                        .split(",")
-                                        .map { it.trim() }
-                                        .filter { it.isNotBlank() && it != "SimpMusic" }
-                                        .toMutableList()
-
-                                if (orderList.isEmpty()) {
-                                    settings[LyricsProviderOrderKey] = ""
-                                } else {
-                                    settings[LyricsProviderOrderKey] = orderList.joinToString(",")
-                                }
-                            }
-
-                            // Reset preferred provider if it was SimpMusic
-                            if (settings[PreferredLyricsProviderKey] == "SIMPMUSIC") {
-                                settings[PreferredLyricsProviderKey] = PreferredLyricsProvider.LRCLIB.name
-                            }
-
-                            settings[SimpMusicMigrationDoneKey] = true
-                        }
-                    }
-
-                    dataStore.edit { settings ->
-                        settings[LastSeenVersionKey] = currentVersion
-                    }
                 }
 
                 val homeViewModel: HomeViewModel = hiltViewModel()
@@ -656,12 +673,19 @@ class MainActivity : ComponentActivity() {
                             Screens.MainScreens
                         }
                     }
+                val routeIndexMap = remember(navigationItems) {
+                    navigationItems.mapIndexed { i, s -> s.route to i }.toMap()
+                }
                 val (slimNav) = rememberPreference(SlimNavBarKey, defaultValue = false)
                 val (useNewMiniPlayerDesign) = rememberPreference(UseNewMiniPlayerDesignKey, defaultValue = true)
-                val defaultOpenTab =
-                    remember {
-                        dataStore[DefaultOpenTabKey].toEnum(defaultValue = NavigationTab.HOME)
+                val (defaultOpenTabInt) = rememberPreference(DefaultOpenTabKey, defaultValue = NavigationTab.HOME.name)
+                val defaultOpenTab = remember(defaultOpenTabInt) {
+                    try {
+                        NavigationTab.valueOf(defaultOpenTabInt)
+                    } catch (_: IllegalArgumentException) {
+                        NavigationTab.HOME
                     }
+                }
                 val tabOpenedFromShortcut =
                     remember {
                         when (intent?.action) {
@@ -1233,16 +1257,9 @@ class MainActivity : ComponentActivity() {
                                             NavigationTab.LIBRARY -> Screens.Library
                                             else -> Screens.Home
                                         }.route,
-                                    // Enter Transition - smoother with smaller offset and longer duration
                                     enterTransition = {
-                                        val currentRouteIndex =
-                                            navigationItems.indexOfFirst {
-                                                it.route == targetState.destination.route
-                                            }
-                                        val previousRouteIndex =
-                                            navigationItems.indexOfFirst {
-                                                it.route == initialState.destination.route
-                                            }
+                                        val currentRouteIndex = routeIndexMap[targetState.destination.route] ?: -1
+                                        val previousRouteIndex = routeIndexMap[initialState.destination.route] ?: -1
 
                                         if (currentRouteIndex == -1 || currentRouteIndex > previousRouteIndex) {
                                             slideInHorizontally { it / 8 } + fadeIn(tween(200))
@@ -1250,16 +1267,9 @@ class MainActivity : ComponentActivity() {
                                             slideInHorizontally { -it / 8 } + fadeIn(tween(200))
                                         }
                                     },
-                                    // Exit Transition - smoother with smaller offset and longer duration
                                     exitTransition = {
-                                        val currentRouteIndex =
-                                            navigationItems.indexOfFirst {
-                                                it.route == initialState.destination.route
-                                            }
-                                        val targetRouteIndex =
-                                            navigationItems.indexOfFirst {
-                                                it.route == targetState.destination.route
-                                            }
+                                        val currentRouteIndex = routeIndexMap[initialState.destination.route] ?: -1
+                                        val targetRouteIndex = routeIndexMap[targetState.destination.route] ?: -1
 
                                         if (targetRouteIndex == -1 || targetRouteIndex > currentRouteIndex) {
                                             slideOutHorizontally { -it / 8 } + fadeOut(tween(200))
@@ -1267,16 +1277,9 @@ class MainActivity : ComponentActivity() {
                                             slideOutHorizontally { it / 8 } + fadeOut(tween(200))
                                         }
                                     },
-                                    // Pop Enter Transition - smoother with smaller offset and longer duration
                                     popEnterTransition = {
-                                        val currentRouteIndex =
-                                            navigationItems.indexOfFirst {
-                                                it.route == targetState.destination.route
-                                            }
-                                        val previousRouteIndex =
-                                            navigationItems.indexOfFirst {
-                                                it.route == initialState.destination.route
-                                            }
+                                        val currentRouteIndex = routeIndexMap[targetState.destination.route] ?: -1
+                                        val previousRouteIndex = routeIndexMap[initialState.destination.route] ?: -1
 
                                         if (previousRouteIndex != -1 && previousRouteIndex < currentRouteIndex) {
                                             slideInHorizontally { it / 8 } + fadeIn(tween(200))
@@ -1284,16 +1287,9 @@ class MainActivity : ComponentActivity() {
                                             slideInHorizontally { -it / 8 } + fadeIn(tween(200))
                                         }
                                     },
-                                    // Pop Exit Transition - smoother with smaller offset and longer duration
                                     popExitTransition = {
-                                        val currentRouteIndex =
-                                            navigationItems.indexOfFirst {
-                                                it.route == initialState.destination.route
-                                            }
-                                        val targetRouteIndex =
-                                            navigationItems.indexOfFirst {
-                                                it.route == targetState.destination.route
-                                            }
+                                        val currentRouteIndex = routeIndexMap[initialState.destination.route] ?: -1
+                                        val targetRouteIndex = routeIndexMap[targetState.destination.route] ?: -1
 
                                         if (currentRouteIndex != -1 && currentRouteIndex < targetRouteIndex) {
                                             slideOutHorizontally { -it / 8 } + fadeOut(tween(200))
diff --git a/app/src/main/kotlin/com/metrolist/music/constants/Dimensions.kt b/app/src/main/kotlin/com/metrolist/music/constants/Dimensions.kt
index 041e1b94bc..5bec328b1e 100644
--- a/app/src/main/kotlin/com/metrolist/music/constants/Dimensions.kt
+++ b/app/src/main/kotlin/com/metrolist/music/constants/Dimensions.kt
@@ -39,7 +39,7 @@ val PlayerHorizontalPadding = 32.dp
 
 val NavigationBarAnimationSpec = spring<Dp>(
     dampingRatio = Spring.DampingRatioNoBouncy,
-    stiffness = Spring.StiffnessLow
+    stiffness = Spring.StiffnessMediumLow
 )
 
 val BottomSheetAnimationSpec = spring<Dp>(
diff --git a/app/src/main/kotlin/com/metrolist/music/listentogether/ListenTogetherClient.kt b/app/src/main/kotlin/com/metrolist/music/listentogether/ListenTogetherClient.kt
index 09bbb70a67..e7e0f83f52 100644
--- a/app/src/main/kotlin/com/metrolist/music/listentogether/ListenTogetherClient.kt
+++ b/app/src/main/kotlin/com/metrolist/music/listentogether/ListenTogetherClient.kt
@@ -311,7 +311,7 @@ class ListenTogetherClient
             ensureNotificationChannel()
             observeAppLifecycle()
             // Load persisted session info asynchronously after construction to avoid calling log() before flows are initialized
-            CoroutineScope(Dispatchers.IO + SupervisorJob()).launch {
+            scope.launch {
                 loadPersistedSession()
                 observeNetworkChanges()
             }
diff --git a/app/src/main/kotlin/com/metrolist/music/playback/MusicService.kt b/app/src/main/kotlin/com/metrolist/music/playback/MusicService.kt
index 595aea9ece..50432c4096 100644
--- a/app/src/main/kotlin/com/metrolist/music/playback/MusicService.kt
+++ b/app/src/main/kotlin/com/metrolist/music/playback/MusicService.kt
@@ -229,6 +229,7 @@ import java.io.ObjectOutputStream
 import java.time.LocalDateTime
 import javax.inject.Inject
 import kotlin.random.Random
+import java.util.Collections
 
 private const val INSTANT_SILENCE_SKIP_STEP_MS = 15_000L
 private const val INSTANT_SILENCE_SKIP_SETTLE_MS = 350L
@@ -415,8 +416,30 @@ class MusicService :
     private var retryCount = 0
     private var silenceSkipJob: Job? = null
 
+    // Cached preferences to avoid runBlocking DataStore reads in hot paths
+    @Volatile
+    private var cachedPersistentQueue = true
+    @Volatile
+    private var cachedAutoplay = true
+    @Volatile
+    private var cachedDisableLoadMoreWhenRepeatAll = false
+    @Volatile
+    private var cachedHideExplicit = false
+    @Volatile
+    private var cachedHideVideoSongs = false
+    @Volatile
+    private var cachedShufflePlaylistFirst = false
+    @Volatile
+    private var cachedAutoLoadMore = true
+
     // URL cache for stream URLs - class-level so it can be invalidated on errors
-    private val songUrlCache = HashMap<String, Pair<String, Long>>()
+    private val songUrlCache = Collections.synchronizedMap(
+        object : LinkedHashMap<String, Pair<String, Long>>(0, 0.75f, true) {
+            override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, Pair<String, Long>>): Boolean {
+                return size > 500
+            }
+        }
+    )
 
     // Flag to bypass cache when quality changes - forces fresh stream fetch
     private val bypassCacheForQualityChange = mutableSetOf<String>()
@@ -935,6 +958,29 @@ class MusicService :
                 crossfadeGapless = gapless
             }
 
+        // Observe and cache common preferences to avoid runBlocking reads in playback callbacks
+        scope.launch {
+            dataStore.data.map { it[PersistentQueueKey] ?: true }.distinctUntilChanged().collect { cachedPersistentQueue = it }
+        }
+        scope.launch {
+            dataStore.data.map { it[AutoplayKey] ?: true }.distinctUntilChanged().collect { cachedAutoplay = it }
+        }
+        scope.launch {
+            dataStore.data.map { it[DisableLoadMoreWhenRepeatAllKey] ?: false }.distinctUntilChanged().collect { cachedDisableLoadMoreWhenRepeatAll = it }
+        }
+        scope.launch {
+            dataStore.data.map { it[HideExplicitKey] ?: false }.distinctUntilChanged().collect { cachedHideExplicit = it }
+        }
+        scope.launch {
+            dataStore.data.map { it[HideVideoSongsKey] ?: false }.distinctUntilChanged().collect { cachedHideVideoSongs = it }
+        }
+        scope.launch {
+            dataStore.data.map { it[ShufflePlaylistFirstKey] ?: false }.distinctUntilChanged().collect { cachedShufflePlaylistFirst = it }
+        }
+        scope.launch {
+            dataStore.data.map { it[AutoLoadMoreKey] ?: true }.distinctUntilChanged().collect { cachedAutoLoadMore = it }
+        }
+
         if (dataStore.get(PersistentQueueKey, true)) {
             val queueFile = filesDir.resolve(PERSISTENT_QUEUE_FILE)
             if (queueFile.exists()) {
@@ -1023,7 +1069,7 @@ class MusicService :
         scope.launch {
             while (isActive) {
                 delay(15.seconds)
-                if (dataStore.get(PersistentQueueKey, true)) {
+                if (cachedPersistentQueue) {
                     saveQueueToDisk()
                 }
                 // Also save episode position periodically
@@ -1039,7 +1085,7 @@ class MusicService :
         scope.launch {
             while (isActive) {
                 delay(10.seconds)
-                if (dataStore.get(PersistentQueueKey, true) && player.isPlaying) {
+                if (cachedPersistentQueue && player.isPlaying) {
                     saveQueueToDisk()
                 }
             }
@@ -1550,8 +1596,8 @@ class MusicService :
                                 songs
                                     .filter { it.id != currentMediaId }
                                     .map { it.toMediaItem() }
-                                    .filterExplicit(dataStore.get(HideExplicitKey, false))
-                                    .filterVideoSongs(dataStore.get(HideVideoSongsKey, false))
+                                    .filterExplicit(cachedHideExplicit)
+                                    .filterVideoSongs(cachedHideVideoSongs)
 
                             if (radioItems.isNotEmpty()) {
                                 val itemCount = player.mediaItemCount
@@ -1560,11 +1606,10 @@ class MusicService :
                                 }
                                 player.addMediaItems(currentIndex + 1, radioItems)
                                 if (player.shuffleModeEnabled) {
-                                    val shufflePlaylistFirst = dataStore.get(ShufflePlaylistFirstKey, false)
                                     applyShuffleOrder(
                                         player.currentMediaItemIndex,
                                         player.mediaItemCount,
-                                        shufflePlaylistFirst,
+                                        cachedShufflePlaylistFirst,
                                     )
                                 }
                             }
@@ -2220,8 +2265,7 @@ class MusicService :
 
         // Force Repeat One if the player ignored it and auto-advanced
         if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO) {
-            val repeatMode = runBlocking { dataStore.get(RepeatModeKey, REPEAT_MODE_OFF) }
-            if (repeatMode == REPEAT_MODE_ONE &&
+            if (player.repeatMode == REPEAT_MODE_ONE &&
                 previousMediaItemIndex != C.INDEX_UNSET &&
                 previousMediaItemIndex != player.currentMediaItemIndex
             ) {
@@ -2260,32 +2304,31 @@ class MusicService :
         }
 
         // Auto load more songs from queue
-        if (dataStore.get(AutoLoadMoreKey, true) &&
+        if (cachedAutoLoadMore &&
             reason != Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT &&
             player.mediaItemCount - player.currentMediaItemIndex <= 5 &&
             currentQueue.hasNextPage() &&
-            !(dataStore.get(DisableLoadMoreWhenRepeatAllKey, false) && player.repeatMode == REPEAT_MODE_ALL)
+            !(cachedDisableLoadMoreWhenRepeatAll && player.repeatMode == REPEAT_MODE_ALL)
         ) {
             scope.launch(SilentHandler) {
                 val mediaItems =
                     withContext(Dispatchers.IO) {
                         currentQueue
                             .nextPage()
-                            .filterExplicit(dataStore.get(HideExplicitKey, false))
-                            .filterVideoSongs(dataStore.get(HideVideoSongsKey, false))
+                            .filterExplicit(cachedHideExplicit)
+                            .filterVideoSongs(cachedHideVideoSongs)
                     }
                 if (player.playbackState != STATE_IDLE && mediaItems.isNotEmpty()) {
                     player.addMediaItems(mediaItems)
                     if (player.shuffleModeEnabled) {
-                        val shufflePlaylistFirst = dataStore.get(ShufflePlaylistFirstKey, false)
-                        applyShuffleOrder(player.currentMediaItemIndex, player.mediaItemCount, shufflePlaylistFirst)
+                        applyShuffleOrder(player.currentMediaItemIndex, player.mediaItemCount, cachedShufflePlaylistFirst)
                     }
                 }
             }
         }
 
         // Save state when media item changes
-        if (dataStore.get(PersistentQueueKey, true)) {
+        if (cachedPersistentQueue) {
             saveQueueToDisk()
         }
     }
@@ -2300,7 +2343,7 @@ class MusicService :
                 return
             }
 
-            val repeatMode = runBlocking { dataStore.get(RepeatModeKey, REPEAT_MODE_OFF) }
+            val repeatMode = player.repeatMode
 
             // Handle Repeat All mode
             if (repeatMode == REPEAT_MODE_ALL && player.mediaItemCount > 0) {
@@ -2319,8 +2362,7 @@ class MusicService :
             }
 
             // Handle autoplay - check if there's a next item to play
-            val autoplay = runBlocking { dataStore.get(AutoplayKey, true) }
-            if (autoplay && player.hasNextMediaItem()) {
+            if (cachedAutoplay && player.hasNextMediaItem()) {
                 player.seekToNextMediaItem()
                 player.prepare()
                 if (castConnectionHandler?.isCasting?.value != true) {
@@ -2330,7 +2372,7 @@ class MusicService :
         }
 
         // Save state when playback state changes (but not during silence skipping)
-        if (dataStore.get(PersistentQueueKey, true) && !isSilenceSkipping) {
+        if (cachedPersistentQueue && !isSilenceSkipping) {
             saveQueueToDisk()
         }
 
@@ -2478,7 +2520,7 @@ class MusicService :
         }
 
         // Save state when shuffle mode changes
-        if (dataStore.get(PersistentQueueKey, true)) {
+        if (cachedPersistentQueue) {
             saveQueueToDisk()
         }
     }
@@ -2492,7 +2534,7 @@ class MusicService :
         }
 
         // Save state when repeat mode changes
-        if (dataStore.get(PersistentQueueKey, true)) {
+        if (cachedPersistentQueue) {
             saveQueueToDisk()
         }
     }
diff --git a/app/src/main/kotlin/com/metrolist/music/ui/component/CreatePlaylistDialog.kt b/app/src/main/kotlin/com/metrolist/music/ui/component/CreatePlaylistDialog.kt
index 5df4ae12fc..d8092718b7 100644
--- a/app/src/main/kotlin/com/metrolist/music/ui/component/CreatePlaylistDialog.kt
+++ b/app/src/main/kotlin/com/metrolist/music/ui/component/CreatePlaylistDialog.kt
@@ -115,23 +115,25 @@ fun CreatePlaylistDialog(
                         Switch(
                             checked = syncedPlaylist,
                             onCheckedChange = {
-                                val isYtmSyncEnabled = context.isSyncEnabled()
-                                if (!isSignedIn && !syncedPlaylist) {
-                                    Toast
-                                        .makeText(
-                                            context,
-                                            notLoggedInYoutubeStr,
-                                            Toast.LENGTH_SHORT,
-                                        ).show()
-                                } else if (!isYtmSyncEnabled) {
-                                    Toast
-                                        .makeText(
-                                            context,
-                                            syncDisabledStr,
-                                            Toast.LENGTH_SHORT,
-                                        ).show()
-                                } else {
-                                    syncedPlaylist = !syncedPlaylist
+                                coroutineScope.launch {
+                                    val isYtmSyncEnabled = withContext(Dispatchers.IO) { context.isSyncEnabled() }
+                                    if (!isSignedIn && !syncedPlaylist) {
+                                        Toast
+                                            .makeText(
+                                                context,
+                                                notLoggedInYoutubeStr,
+                                                Toast.LENGTH_SHORT,
+                                            ).show()
+                                    } else if (!isYtmSyncEnabled) {
+                                        Toast
+                                            .makeText(
+                                                context,
+                                                syncDisabledStr,
+                                                Toast.LENGTH_SHORT,
+                                            ).show()
+                                    } else {
+                                        syncedPlaylist = !syncedPlaylist
+                                    }
                                 }
                             },
                         )
diff --git a/app/src/main/kotlin/com/metrolist/music/ui/component/ExperimentalLyrics.kt b/app/src/main/kotlin/com/metrolist/music/ui/component/ExperimentalLyrics.kt
index d6613dc8ca..2d764a2a19 100644
--- a/app/src/main/kotlin/com/metrolist/music/ui/component/ExperimentalLyrics.kt
+++ b/app/src/main/kotlin/com/metrolist/music/ui/component/ExperimentalLyrics.kt
@@ -53,6 +53,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.withFrameNanos
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
@@ -344,7 +345,7 @@ fun ExperimentalLyrics(
         var lastUpdateTime = System.currentTimeMillis()
         
         while (isActive) {
-            delay(16)
+            withFrameNanos { _ -> }
             val now = System.currentTimeMillis()
             val sliderPosition = sliderPositionProvider()
             isSeeking = sliderPosition != null
diff --git a/app/src/main/kotlin/com/metrolist/music/ui/component/LyricsLine.kt b/app/src/main/kotlin/com/metrolist/music/ui/component/LyricsLine.kt
index 702e9e2a46..b9c162a593 100644
--- a/app/src/main/kotlin/com/metrolist/music/ui/component/LyricsLine.kt
+++ b/app/src/main/kotlin/com/metrolist/music/ui/component/LyricsLine.kt
@@ -44,6 +44,7 @@ import androidx.compose.ui.graphics.drawscope.drawIntoCanvas
 import androidx.compose.ui.graphics.drawscope.scale
 import androidx.compose.ui.graphics.drawscope.translate
 import androidx.compose.ui.graphics.drawscope.withTransform
+import androidx.compose.ui.graphics.CompositingStrategy
 import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.graphics.nativeCanvas
 import androidx.compose.ui.graphics.toArgb
@@ -511,7 +512,10 @@ private fun WordLevelLyrics(
         Canvas(modifier = Modifier
             .fillMaxWidth()
             .height(with(density) { layoutResult.size.height.toDp() })
-            .graphicsLayer(clip = false)
+            .graphicsLayer(
+                clip = false,
+                compositingStrategy = CompositingStrategy.Offscreen,
+            )
         ) {
             if (mainText.isEmpty()) return@Canvas
             if (!isActiveLine) {
diff --git a/app/src/main/kotlin/com/metrolist/music/ui/component/SpeedDialGridItem.kt b/app/src/main/kotlin/com/metrolist/music/ui/component/SpeedDialGridItem.kt
index 4a98ebe18a..d12be81458 100644
--- a/app/src/main/kotlin/com/metrolist/music/ui/component/SpeedDialGridItem.kt
+++ b/app/src/main/kotlin/com/metrolist/music/ui/component/SpeedDialGridItem.kt
@@ -46,7 +46,7 @@ fun SpeedDialGridItem(
     ) {
         // Thumbnail
         ItemThumbnail(
-            thumbnailUrl = item.thumbnail?.resize(1080, 1080),
+            thumbnailUrl = item.thumbnail?.resize(200, 200),
             isActive = isActive,
             isPlaying = isPlaying,
             shape = if (item is ArtistItem) CircleShape else RoundedCornerShape(ThumbnailCornerRadius),
diff --git a/app/src/main/kotlin/com/metrolist/music/ui/menu/SelectionSongsMenu.kt b/app/src/main/kotlin/com/metrolist/music/ui/menu/SelectionSongsMenu.kt
index 31aedabbd4..5bce99c940 100644
--- a/app/src/main/kotlin/com/metrolist/music/ui/menu/SelectionSongsMenu.kt
+++ b/app/src/main/kotlin/com/metrolist/music/ui/menu/SelectionSongsMenu.kt
@@ -66,7 +66,6 @@ import com.metrolist.music.ui.component.NewAction
 import com.metrolist.music.ui.component.NewActionGrid
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
 import java.time.LocalDateTime
 
@@ -692,13 +691,10 @@ fun SelectionMediaMetadataMenu(
     AddToPlaylistDialog(
         isVisible = showChoosePlaylistDialog,
         onGetSong = {
-            songSelection.map {
-                runBlocking {
-                    withContext(Dispatchers.IO) {
-                        database.insert(it)
-                    }
-                }
-                it.id
+            // Safe: AddToPlaylistDialog wraps this lambda in withContext(Dispatchers.IO)
+            songSelection.map { song ->
+                database.insert(song)
+                song.id
             }
         },
         onGetSongIds = { songSelection.map { it.id } },
diff --git a/app/src/main/kotlin/com/metrolist/music/ui/screens/HomeScreen.kt b/app/src/main/kotlin/com/metrolist/music/ui/screens/HomeScreen.kt
index 70cdf4faf0..4ccec7e21d 100644
--- a/app/src/main/kotlin/com/metrolist/music/ui/screens/HomeScreen.kt
+++ b/app/src/main/kotlin/com/metrolist/music/ui/screens/HomeScreen.kt
@@ -35,6 +35,7 @@ import androidx.compose.foundation.lazy.LazyRow
 import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.LazyHorizontalGrid
 import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.foundation.lazy.grid.LazyGridState
 import androidx.compose.foundation.lazy.grid.rememberLazyGridState
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.rememberLazyListState
@@ -675,6 +676,8 @@ fun HomeScreen(
     val innerTubeCookie by rememberPreference(InnerTubeCookieKey, "")
     val (randomizeHomeOrder) = rememberPreference(RandomizeHomeOrderKey, true)
 
+    LaunchedEffect(Unit) { viewModel.loadHomeData() }
+
     val shouldShowWrappedCard by viewModel.showWrappedCard.collectAsStateWithLifecycle()
     val wrappedState by viewModel.wrappedManager.state.collectAsStateWithLifecycle()
     val isWrappedDataReady = wrappedState.isDataReady
@@ -1211,7 +1214,7 @@ fun HomeScreen(
                                         .only(WindowInsetsSides.Horizontal)
                                         .asPaddingValues(),
                             ) {
-                                items(savedPodcastShows) { podcast ->
+                                items(savedPodcastShows, key = { it.id }) { podcast ->
                                     ytGridItem(podcast)
                                 }
                             }
@@ -1236,7 +1239,7 @@ fun HomeScreen(
                                         .only(WindowInsetsSides.Horizontal)
                                         .asPaddingValues(),
                             ) {
-                                items(episodesForLater) { episode ->
+                                items(episodesForLater, key = { it.id }) { episode ->
                                     ytGridItem(episode)
                                 }
                             }
@@ -1259,7 +1262,7 @@ fun HomeScreen(
                                         .only(WindowInsetsSides.Horizontal)
                                         .asPaddingValues(),
                             ) {
-                                items(featuredPodcasts) { podcast ->
+                                items(featuredPodcasts, key = { it.id }) { podcast ->
                                     ytGridItem(podcast)
                                 }
                             }
@@ -1331,7 +1334,6 @@ fun HomeScreen(
                                                 }
                                             }
                                         },
-                                    modifier = Modifier.animateItem(),
                                 )
                             }
 
@@ -1342,7 +1344,7 @@ fun HomeScreen(
                                             .only(WindowInsetsSides.Horizontal)
                                             .asPaddingValues(),
                                 ) {
-                                    items(sectionData.items) { item ->
+                                    items(sectionData.items, key = { it.id }) { item ->
                                         ytGridItem(item)
                                     }
                                 }
@@ -1421,7 +1423,6 @@ fun HomeScreen(
                                 item(key = "speed_dial_title") {
                                     NavigationTitle(
                                         title = stringResource(R.string.speed_dial),
-                                        modifier = Modifier.animateItem(),
                                     )
                                 }
 
@@ -1445,8 +1446,7 @@ fun HomeScreen(
                                     Column(
                                         modifier =
                                             Modifier
-                                                .fillMaxWidth()
-                                                .animateItem(),
+                                                .fillMaxWidth(),
                                     ) {
                                         HorizontalPager(
                                             state = pagerState,
@@ -1737,7 +1737,6 @@ fun HomeScreen(
                                     val quickPicksTitle = stringResource(R.string.quick_picks)
                                     NavigationTitle(
                                         title = quickPicksTitle,
-                                        modifier = Modifier.animateItem(),
                                         onPlayAllClick =
                                             if (!isListenTogetherGuest) {
                                                 {
@@ -1766,12 +1765,11 @@ fun HomeScreen(
                                         modifier =
                                             Modifier
                                                 .fillMaxWidth()
-                                                .height(ListItemHeight * 4)
-                                                .animateItem(),
-                                    ) {
-                                        items(
-                                            items = quickPicks.distinctBy { it.id },
-                                            key = { "home_quickpick_${it.id}" },
+                                                .height(ListItemHeight * 4),
+                                        ) {
+                                            items(
+                                                items = quickPicks.distinctBy { it.id },
+                                                key = { "home_quickpick_${it.id}" },
                                         ) { originalSong ->
                                             // fetch song from database to keep updated
                                             val song by database
@@ -1842,7 +1840,6 @@ fun HomeScreen(
                                 item(key = "community_playlists_title") {
                                     NavigationTitle(
                                         title = stringResource(R.string.from_the_community),
-                                        modifier = Modifier.animateItem(),
                                     )
                                 }
 
@@ -1850,7 +1847,6 @@ fun HomeScreen(
                                     LazyRow(
                                         contentPadding = PaddingValues(horizontal = 16.dp),
                                         horizontalArrangement = Arrangement.spacedBy(16.dp),
-                                        modifier = Modifier.animateItem(),
                                     ) {
                                         items(playlists) { item ->
                                             CommunityPlaylistCard(
@@ -1949,14 +1945,13 @@ fun HomeScreen(
                                 item(key = "keep_listening_title") {
                                     NavigationTitle(
                                         title = stringResource(R.string.keep_listening),
-                                        modifier = Modifier.animateItem(),
                                     )
                                 }
 
                                 item(key = "keep_listening_list") {
                                     val rows = if (keepListening.size > 6) 2 else 1
                                     LazyHorizontalGrid(
-                                        state = rememberLazyGridState(),
+                                        state = remember("keep_listening_grid") { LazyGridState() },
                                         rows = GridCells.Fixed(rows),
                                         contentPadding =
                                             WindowInsets.systemBars
@@ -1975,9 +1970,9 @@ fun HomeScreen(
                                                                         .toDp() * 2
                                                             }
                                                     ) * rows,
-                                                ).animateItem(),
+                                                ),
                                     ) {
-                                        items(keepListening) {
+                                        items(keepListening, key = { it.id }) {
                                             localGridItem(it)
                                         }
                                     }
@@ -2022,7 +2017,6 @@ fun HomeScreen(
                                         onClick = {
                                             navController.navigate("account")
                                         },
-                                        modifier = Modifier.animateItem(),
                                     )
                                 }
 
@@ -2032,7 +2026,6 @@ fun HomeScreen(
                                             WindowInsets.systemBars
                                                 .only(WindowInsetsSides.Horizontal)
                                                 .asPaddingValues(),
-                                        modifier = Modifier.animateItem(),
                                     ) {
                                         items(
                                             items = accountPlaylists.distinctBy { it.id },
@@ -2051,7 +2044,6 @@ fun HomeScreen(
                                     val forgottenFavoritesTitle = stringResource(R.string.forgotten_favorites)
                                     NavigationTitle(
                                         title = forgottenFavoritesTitle,
-                                        modifier = Modifier.animateItem(),
                                         onPlayAllClick =
                                             if (!isListenTogetherGuest) {
                                                 {
@@ -2085,11 +2077,10 @@ fun HomeScreen(
                                         modifier =
                                             Modifier
                                                 .fillMaxWidth()
-                                                .height(ListItemHeight * rows)
-                                                .animateItem(),
-                                    ) {
-                                        items(
-                                            items = forgottenFavorites.distinctBy { it.id },
+                                                .height(ListItemHeight * rows),
+                                        ) {
+                                            items(
+                                                items = forgottenFavorites.distinctBy { it.id },
                                             key = { "home_forgotten_${it.id}" },
                                         ) { originalSong ->
                                             val song by database
@@ -2201,7 +2192,6 @@ fun HomeScreen(
                                                 is Playlist -> {}
                                             }
                                         },
-                                        modifier = Modifier.animateItem(),
                                     )
                                 }
 
@@ -2211,9 +2201,8 @@ fun HomeScreen(
                                             WindowInsets.systemBars
                                                 .only(WindowInsetsSides.Horizontal)
                                                 .asPaddingValues(),
-                                        modifier = Modifier.animateItem(),
                                     ) {
-                                        items(recommendation.items) { item ->
+                                        items(recommendation.items, key = { it.id }) { item ->
                                             ytGridItem(item)
                                         }
                                     }
@@ -2301,7 +2290,6 @@ fun HomeScreen(
                                             } else {
                                                 null
                                             },
-                                        modifier = Modifier.animateItem(),
                                     )
                                 }
 
@@ -2309,7 +2297,7 @@ fun HomeScreen(
                                     // Render songs as a horizontal scrollable list (like Quick picks in YouTube Music)
                                     item(key = "home_section_list_${section.index}") {
                                         LazyHorizontalGrid(
-                                            state = rememberLazyGridState(),
+                                            state = remember("section_${section.index}_grid") { LazyGridState() },
                                             rows = GridCells.Fixed(4),
                                             contentPadding =
                                                 WindowInsets.systemBars
@@ -2318,8 +2306,7 @@ fun HomeScreen(
                                             modifier =
                                                 Modifier
                                                     .fillMaxWidth()
-                                                    .height(ListItemHeight * 4)
-                                                    .animateItem(),
+                                                    .height(ListItemHeight * 4),
                                         ) {
                                             items(
                                                 items = sectionSongs.distinctBy { it.id },
@@ -2385,7 +2372,6 @@ fun HomeScreen(
                                                 WindowInsets.systemBars
                                                     .only(WindowInsetsSides.Horizontal)
                                                     .asPaddingValues(),
-                                            modifier = Modifier.animateItem(),
                                         ) {
                                             items(
                                                 items = sectionData.items.distinctBy { it.id },
@@ -2411,7 +2397,6 @@ fun HomeScreen(
                                         onClick = {
                                             navController.navigate("mood_and_genres")
                                         },
-                                        modifier = Modifier.animateItem(),
                                     )
                                 }
                                 item(key = "mood_and_genres_list") {
@@ -2420,10 +2405,9 @@ fun HomeScreen(
                                         contentPadding = PaddingValues(6.dp),
                                         modifier =
                                             Modifier
-                                                .height((MoodAndGenresButtonHeight + 12.dp) * 4 + 12.dp)
-                                                .animateItem(),
+                                                .height((MoodAndGenresButtonHeight + 12.dp) * 4 + 12.dp),
                                     ) {
-                                        items(moodAndGenres) {
+                                        items(moodAndGenres, key = { it.title }) {
                                             MoodAndGenresButton(
                                                 title = it.title,
                                                 onClick = {
@@ -2448,7 +2432,6 @@ fun HomeScreen(
                 if (isLoading && homePage?.sections.isNullOrEmpty()) {
                     item(key = "loading_shimmer") {
                         ShimmerHost(
-                            modifier = Modifier.animateItem(),
                         ) {
                             repeat(2) {
                                 TextPlaceholder(
diff --git a/app/src/main/kotlin/com/metrolist/music/ui/screens/playlist/LocalPlaylistScreen.kt b/app/src/main/kotlin/com/metrolist/music/ui/screens/playlist/LocalPlaylistScreen.kt
index 3617eb1287..ad984d6e80 100644
--- a/app/src/main/kotlin/com/metrolist/music/ui/screens/playlist/LocalPlaylistScreen.kt
+++ b/app/src/main/kotlin/com/metrolist/music/ui/screens/playlist/LocalPlaylistScreen.kt
@@ -65,10 +65,8 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
-import androidx.compose.runtime.saveable.listSaver
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
-import androidx.compose.runtime.toMutableStateList
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.shadow
@@ -222,16 +220,12 @@ fun LocalPlaylistScreen(
         }
     }
 
-    var inSelectMode by rememberSaveable { mutableStateOf(false) }
+    var inSelectMode by remember { mutableStateOf(false) }
     val selection =
-        rememberSaveable(
-            saver =
-                listSaver<MutableList<Int>, Int>(
-                    save = { it.toList() },
-                    restore = { it.toMutableStateList() },
-                ),
-        ) { mutableStateListOf() }
-    var selectionAnchorMapId by rememberSaveable { mutableStateOf<Int?>(null) }
+        remember {
+            mutableStateListOf<Int>()
+        }
+    var selectionAnchorMapId by remember { mutableStateOf<Int?>(null) }
     val onExitSelectionMode = {
         inSelectMode = false
         selection.clear()
diff --git a/app/src/main/kotlin/com/metrolist/music/ui/screens/playlist/OnlinePlaylistScreen.kt b/app/src/main/kotlin/com/metrolist/music/ui/screens/playlist/OnlinePlaylistScreen.kt
index 2d3ef8a087..12519467d1 100644
--- a/app/src/main/kotlin/com/metrolist/music/ui/screens/playlist/OnlinePlaylistScreen.kt
+++ b/app/src/main/kotlin/com/metrolist/music/ui/screens/playlist/OnlinePlaylistScreen.kt
@@ -49,10 +49,8 @@ import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.saveable.listSaver
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
-import androidx.compose.runtime.toMutableStateList
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.shadow
@@ -153,16 +151,12 @@ fun OnlinePlaylistScreen(
             }
         }
 
-    var inSelectMode by rememberSaveable { mutableStateOf(false) }
+    var inSelectMode by remember { mutableStateOf(false) }
     val selection =
-        rememberSaveable(
-            saver =
-                listSaver<MutableList<String>, String>(
-                    save = { it.toList() },
-                    restore = { it.toMutableStateList() },
-                ),
-        ) { mutableStateListOf() }
-    var selectionAnchorSongId by rememberSaveable { mutableStateOf<String?>(null) }
+        remember {
+            mutableStateListOf<String>()
+        }
+    var selectionAnchorSongId by remember { mutableStateOf<String?>(null) }
     val onExitSelectionMode = {
         inSelectMode = false
         selection.clear()
diff --git a/app/src/main/kotlin/com/metrolist/music/ui/screens/wrapped/WrappedManager.kt b/app/src/main/kotlin/com/metrolist/music/ui/screens/wrapped/WrappedManager.kt
index c49c3483e7..59643803ad 100644
--- a/app/src/main/kotlin/com/metrolist/music/ui/screens/wrapped/WrappedManager.kt
+++ b/app/src/main/kotlin/com/metrolist/music/ui/screens/wrapped/WrappedManager.kt
@@ -17,6 +17,7 @@ import com.metrolist.music.db.entities.PlaylistEntity
 import com.metrolist.music.db.entities.SongWithStats
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
@@ -237,4 +238,8 @@ class WrappedManager(
         _state.update { it.copy(isDataReady = true) }
         Timber.tag("WrappedManager").d("Wrapped data preparation finished")
     }
+
+    fun dispose() {
+        scope.cancel()
+    }
 }
diff --git a/app/src/main/kotlin/com/metrolist/music/utils/DataStore.kt b/app/src/main/kotlin/com/metrolist/music/utils/DataStore.kt
index eca89a0cba..d8a3e64594 100644
--- a/app/src/main/kotlin/com/metrolist/music/utils/DataStore.kt
+++ b/app/src/main/kotlin/com/metrolist/music/utils/DataStore.kt
@@ -65,7 +65,7 @@ fun <T> rememberPreference(
             context.dataStore.data
                 .map { it[key] ?: defaultValue }
                 .distinctUntilChanged()
-        }.collectAsStateWithLifecycle(context.dataStore[key] ?: defaultValue)
+        }.collectAsStateWithLifecycle(defaultValue)
 
     return remember {
         object : MutableState<T> {
@@ -94,13 +94,12 @@ inline fun <reified T : Enum<T>> rememberEnumPreference(
     val context = LocalContext.current
     val coroutineScope = rememberCoroutineScope()
 
-    val initialValue = context.dataStore[key].toEnum(defaultValue = defaultValue)
     val state =
         remember {
             context.dataStore.data
                 .map { it[key].toEnum(defaultValue = defaultValue) }
                 .distinctUntilChanged()
-        }.collectAsStateWithLifecycle(initialValue)
+        }.collectAsStateWithLifecycle(defaultValue)
 
     return remember {
         object : MutableState<T> {
diff --git a/app/src/main/kotlin/com/metrolist/music/viewmodels/HomeViewModel.kt b/app/src/main/kotlin/com/metrolist/music/viewmodels/HomeViewModel.kt
index b570d5bd26..2979d91422 100644
--- a/app/src/main/kotlin/com/metrolist/music/viewmodels/HomeViewModel.kt
+++ b/app/src/main/kotlin/com/metrolist/music/viewmodels/HomeViewModel.kt
@@ -59,6 +59,7 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
+import timber.log.Timber
 import java.time.LocalDate
 import javax.inject.Inject
 import kotlin.random.Random
@@ -703,17 +704,12 @@ class HomeViewModel @Inject constructor(
         }
     }
 
-    init {
-        // Load home data
-        viewModelScope.launch(Dispatchers.IO) {
-            context.dataStore.data
-                .map { it[InnerTubeCookieKey] }
-                .distinctUntilChanged()
-                .first()
-
-            load()
-        }
+    override fun onCleared() {
+        super.onCleared()
+        wrappedManager.dispose()
+    }
 
+    init {
         // Run sync in separate coroutine with cooldown to avoid blocking UI
         viewModelScope.launch(Dispatchers.IO) {
             syncUtils.tryAutoSync()
@@ -743,20 +739,15 @@ class HomeViewModel @Inject constructor(
             context.dataStore.data
                 .map { it[InnerTubeCookieKey] }
                 .collect { cookie ->
-                    // Avoid processing if already processing
                     if (isProcessingAccountData) return@collect
 
-                    // Always process cookie changes, even if same value (for logout/login scenarios)
                     lastProcessedCookie = cookie
                     isProcessingAccountData = true
 
                     try {
                         if (cookie != null && cookie.isNotEmpty()) {
-
-                            // Update YouTube.cookie manually to ensure it's set
                             YouTube.cookie = cookie
 
-                            // Fetch new account data
                             YouTube.accountInfo().onSuccess { info ->
                                 accountName.value = info.name
                                 accountImageUrl.value = info.thumbnailUrl
@@ -786,4 +777,28 @@ class HomeViewModel @Inject constructor(
                 }
         }
     }
+
+    private var isHomeDataLoaded = false
+
+    fun loadHomeData() {
+        if (isHomeDataLoaded) return
+        viewModelScope.launch(Dispatchers.IO) {
+            try {
+                val cookie = context.dataStore.data
+                    .map { it[InnerTubeCookieKey] }
+                    .distinctUntilChanged()
+                    .first()
+
+                if (!cookie.isNullOrEmpty()) {
+                    YouTube.cookie = cookie
+                }
+
+                isHomeDataLoaded = true
+                load()
+            } catch (e: Exception) {
+                isHomeDataLoaded = false
+                Timber.e(e, "Failed to load home data")
+            }
+        }
+    }
 }
diff --git a/app/src/main/kotlin/com/metrolist/music/viewmodels/LibraryViewModels.kt b/app/src/main/kotlin/com/metrolist/music/viewmodels/LibraryViewModels.kt
index c591287e40..ad5d38ea22 100644
--- a/app/src/main/kotlin/com/metrolist/music/viewmodels/LibraryViewModels.kt
+++ b/app/src/main/kotlin/com/metrolist/music/viewmodels/LibraryViewModels.kt
@@ -187,7 +187,8 @@ constructor(
                             it.lastUpdateTime,
                             LocalDateTime.now()
                         ) > Duration.ofDays(10)
-                    }.forEach { artist ->
+                    }.take(5)
+                    .forEach { artist ->
                         YouTube.artist(artist.id).onSuccess { artistPage ->
                             database.query {
                                 update(artist, artistPage)
@@ -248,7 +249,8 @@ constructor(
                 albums
                     .filter {
                         it.album.songCount == 0
-                    }.forEach { album ->
+                    }.take(5)
+                    .forEach { album ->
                         YouTube
                             .album(album.id)
                             .onSuccess { albumPage ->
@@ -418,7 +420,8 @@ constructor(
                 albums
                     .filter {
                         it.album.songCount == 0
-                    }.forEach { album ->
+                    }.take(5)
+                    .forEach { album ->
                         YouTube
                             .album(album.id)
                             .onSuccess { albumPage ->
@@ -446,7 +449,8 @@ constructor(
                                     it.lastUpdateTime,
                                     LocalDateTime.now(),
                                 ) > Duration.ofDays(10)
-                    }.forEach { artist ->
+                    }.take(5)
+                    .forEach { artist ->
                         YouTube.artist(artist.id).onSuccess { artistPage ->
                             database.query {
                                 update(artist, artistPage)
diff --git a/app/src/main/kotlin/com/metrolist/music/viewmodels/LyricsViewModel.kt b/app/src/main/kotlin/com/metrolist/music/viewmodels/LyricsViewModel.kt
index b601fa0684..dacc737cf5 100644
--- a/app/src/main/kotlin/com/metrolist/music/viewmodels/LyricsViewModel.kt
+++ b/app/src/main/kotlin/com/metrolist/music/viewmodels/LyricsViewModel.kt
@@ -22,6 +22,10 @@ import kotlinx.coroutines.withContext
 
 @HiltViewModel
 class LyricsViewModel @Inject constructor() : ViewModel() {
+    companion object {
+        private val timestampRegex = Regex("\\[\\d{1,2}:\\d{2}")
+    }
+
     private var processJob: kotlinx.coroutines.Job? = null
 
     private val _lines = MutableStateFlow<List<LyricsEntry>>(emptyList())
@@ -42,7 +46,6 @@ class LyricsViewModel @Inject constructor() : ViewModel() {
                 if (lyrics == null || lyrics == LYRICS_NOT_FOUND) {
                     emptyList()
                 } else {
-                    val timestampRegex = Regex("\\[\\d{1,2}:\\d{2}")
                     val isLrc = timestampRegex.containsMatchIn(lyrics)
                     val parsedLines = if (isLrc) LyricsUtils.parseLyrics(lyrics) else emptyList()
                     
@@ -50,7 +53,7 @@ class LyricsViewModel @Inject constructor() : ViewModel() {
                         listOf(LyricsEntry.HEAD_LYRICS_ENTRY) + parsedLines
                     } else {
                         // Fallback for unsynced or invalid LRC
-                        val baseTime = 1000000L // Start at 1000s to avoid overlap with real start
+                        val baseTime = 1000000L
                         lyrics.lines()
                             .filter { it.isNotBlank() && !timestampRegex.containsMatchIn(it) }
                             .mapIndexed { index, line ->