fix(lt): multiple issues

- fixes host/guest desync during quick actions
- fixes minor ui glitches

Author: nyxiereal

app/src/main/kotlin/com/metrolist/music/listentogether/ListenTogetherManager.kt

@@ -47,6 +47,10 @@ class ListenTogetherManager @Inject constructor(
 ) {
     companion object {
         private const val TAG = "ListenTogetherManager"
+        // Debounce threshold for playback syncs - prevents excessive seeking/pausing
+        private const val SYNC_DEBOUNCE_THRESHOLD_MS = 200L
+        // Position tolerance - only seek if difference exceeds this (prevents micro-adjustments)
+        private const val POSITION_TOLERANCE_MS = 500L
     }
 
     private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
@@ -76,11 +80,18 @@ class ListenTogetherManager @Inject constructor(
     private var lastSyncedIsPlaying: Boolean? = null
     private var lastSyncedTrackId: String? = null
 
+    // Track last sync action time for debouncing (prevents excessive seeking/pausing)
+    private var lastSyncActionTime: Long = 0L
+    
     // Track ID being buffered
     private var bufferingTrackId: String? = null
 
     // Track active sync job to cancel it if a better update arrives
     private var activeSyncJob: Job? = null
+    
+    // Generation ID for track changes - incremented on each new track change
+    // Used to prevent old coroutines from overwriting newer track loads
+    private var currentTrackGeneration: Int = 0
 
     // Pending sync to apply after buffering completes for guest
     private var pendingSyncState: SyncStatePayload? = null
@@ -674,6 +685,8 @@ class ListenTogetherManager @Inject constructor(
         isSyncing = false
         bufferCompleteReceivedForTrack = null
         lastRole = RoomRole.NONE
+        lastSyncActionTime = 0L  // Reset sync debouncing
+        ++currentTrackGeneration  // Increment to invalidate any pending track-change coroutines
     }
 
     private fun updateGuestMuteState() {
@@ -699,17 +712,22 @@ class ListenTogetherManager @Inject constructor(
     /**
      * Restore the mute state that was saved when joining the room.
      * This is called when leaving the room to ensure the user's
-     * mute preference is restored (unmuted by default if they muted during session).
+     * mute preference is restored to what it was before joining Listen Together.
      */
     private fun restoreGuestMuteState() {
         val connection = playerConnection ?: return
         val savedState = previousMuteState
 
-        // If player is currently muted, unmute it when leaving Listen Together
-        // This addresses the issue where mute state persists after leaving
-        if (connection.isMuted.value) {
-            Timber.tag(TAG).d("Unmuting player on leave (was muted during Listen Together session)")
-            connection.setMuted(false)
+        if (savedState != null) {
+            Timber.tag(TAG).d("Restoring mute state on leave: was muted=$savedState, currently muted=${connection.isMuted.value}")
+            connection.setMuted(savedState)
+        } else {
+            // No saved state means we never properly saved (e.g., player wasn't ready on join)
+            // In this case, if currently muted, unmute as a fallback
+            if (connection.isMuted.value) {
+                Timber.tag(TAG).d("No saved mute state on leave, unmuting player as fallback")
+                connection.setMuted(false)
+            }
         }
 
         previousMuteState = null
@@ -795,50 +813,73 @@ class ListenTogetherManager @Inject constructor(
                         return
                     }
 
-                    // Seek first for precision, then play
-                    if (kotlin.math.abs(player.currentPosition - adjustedPos) > 100) {
+                    // Seek first for precision, then play (use larger position tolerance to reduce stuttering)
+                    if (kotlin.math.abs(player.currentPosition - adjustedPos) > POSITION_TOLERANCE_MS) {
                         connection.seekTo(adjustedPos)
+                        Timber.tag(TAG).d("Guest: PLAY seeking from ${player.currentPosition} to $adjustedPos (diff > ${POSITION_TOLERANCE_MS}ms)")
                     }
                     // Start playback immediately for tighter sync
                     connection.play()
+                    lastSyncActionTime = now
                 }
 
                 PlaybackActions.PAUSE -> {
                     val pos = action.position ?: 0L
+                    val now = System.currentTimeMillis()
+                    
                     Timber.tag(TAG).d("Guest: PAUSE at position $pos")
 
                     if (bufferingTrackId != null) {
                         pendingSyncState = (pendingSyncState ?: SyncStatePayload(
                             currentTrack = roomState.value?.currentTrack,
                             isPlaying = false,
                             position = pos,
-                            lastUpdate = System.currentTimeMillis()
+                            lastUpdate = now
                         )).copy(
                             isPlaying = false,
                             position = pos,
-                            lastUpdate = System.currentTimeMillis()
+                            lastUpdate = now
                         )
                         applyPendingSyncIfReady()
                         return
                     }
 
-                    // Pause first, then seek for accuracy
+                    // Pause first, then seek for accuracy (use larger position tolerance)
                     connection.pause()
-                    if (kotlin.math.abs(player.currentPosition - pos) > 100) {
+                    if (kotlin.math.abs(player.currentPosition - pos) > POSITION_TOLERANCE_MS) {
                         connection.seekTo(pos)
+                        Timber.tag(TAG).d("Guest: PAUSE seeking from ${player.currentPosition} to $pos (diff > ${POSITION_TOLERANCE_MS}ms)")
                     }
+                    lastSyncActionTime = now
                 }
 
                 PlaybackActions.SEEK -> {
                     val pos = action.position ?: 0L
-                    Timber.tag(TAG).d("Guest: SEEK to $pos")
-                    connection.seekTo(pos)
+                    val now = System.currentTimeMillis()
+                    
+                    // Debounce SEEK actions - don't seek if one just happened
+                    if (now - lastSyncActionTime < SYNC_DEBOUNCE_THRESHOLD_MS) {
+                        Timber.tag(TAG).d("Guest: SEEK debounced (only ${now - lastSyncActionTime}ms since last sync)")
+                        return
+                    }
+                    
+                    // Use larger position tolerance
+                    if (kotlin.math.abs(player.currentPosition - pos) > POSITION_TOLERANCE_MS) {
+                        Timber.tag(TAG).d("Guest: SEEK to $pos from ${player.currentPosition} (diff > ${POSITION_TOLERANCE_MS}ms)")
+                        connection.seekTo(pos)
+                        lastSyncActionTime = now
+                    } else {
+                        Timber.tag(TAG).d("Guest: SEEK ignored (position diff < ${POSITION_TOLERANCE_MS}ms)")
+                    }
                 }
 
                 PlaybackActions.CHANGE_TRACK -> {
                     action.trackInfo?.let { track ->
                         Timber.tag(TAG).d("Guest: CHANGE_TRACK to ${track.title}, queue size=${action.queue?.size}")
 
+                        // Reset sync debounce timer on track change - this is a fresh sync cycle
+                        lastSyncActionTime = 0L
+                        
                         // If we have a queue, use it! This is the "smart" sync path.
                         if (action.queue != null && action.queue.isNotEmpty()) {
                             val queueTitle = action.queueTitle
@@ -1030,7 +1071,14 @@ class ListenTogetherManager @Inject constructor(
         // If no track, just pause and clear/set queue
         if (currentTrack == null) {
             Timber.tag(TAG).d("No track in state, pausing")
+            val generation = ++currentTrackGeneration
             scope.launch(Dispatchers.Main) {
+                // Verify we're still on the same track generation (no newer track change arrived)
+                if (currentTrackGeneration != generation) {
+                    Timber.tag(TAG).d("Skipping stale track generation: $generation vs current $currentTrackGeneration")
+                    return@launch
+                }
+                
                 if (playerConnection !== connection) return@launch
                 isSyncing = true
                 connection.allowInternalSync = true
@@ -1053,13 +1101,26 @@ class ListenTogetherManager @Inject constructor(
         }
 
         bufferingTrackId = currentTrack.id
+        val generation = ++currentTrackGeneration
 
         scope.launch(Dispatchers.Main) {
+            // Verify we're still on the same track generation (no newer track change arrived)
+            if (currentTrackGeneration != generation) {
+                Timber.tag(TAG).d("Skipping stale track generation: $generation vs current $currentTrackGeneration (track ${currentTrack.id})")
+                return@launch
+            }
+            
             if (playerConnection !== connection) return@launch
             isSyncing = true
             connection.allowInternalSync = true
 
             try {
+                // Re-verify generation before applying media items (critical section)
+                if (currentTrackGeneration != generation) {
+                    Timber.tag(TAG).d("Stale generation detected before setMediaItems: $generation vs $currentTrackGeneration")
+                    return@launch
+                }
+                
                 // Apply queue/media (same)
                 if (queue != null && queue.isNotEmpty()) {
                     val mediaItems = queue.map { it.toMediaMetadata().toMediaItem() }
@@ -1150,14 +1211,29 @@ class ListenTogetherManager @Inject constructor(
 
         // Track which buffer-complete we expect for this load
         bufferingTrackId = track.id
+        val generation = currentTrackGeneration
 
         activeSyncJob?.cancel()
         activeSyncJob = scope.launch(Dispatchers.IO) {
             try {
+                // Check if a newer track change arrived - skip this load if stale
+                if (currentTrackGeneration != generation) {
+                    Timber.tag(TAG).d("Skipping stale syncToTrack for ${track.id} (generation $generation vs $currentTrackGeneration)")
+                    isSyncing = false
+                    return@launch
+                }
+                
                 // Use YouTube API to play the track by ID
                 YouTube.queue(listOf(track.id)).onSuccess { queue ->
                     Timber.tag(TAG).d("Got queue for track ${track.id}")
                     launch(Dispatchers.Main) {
+                        // Final generation check before applying changes
+                        if (currentTrackGeneration != generation) {
+                            Timber.tag(TAG).d("Skipping stale track application for ${track.id} (generation $generation vs $currentTrackGeneration)")
+                            isSyncing = false
+                            return@launch
+                        }
+                        
                         val connection = playerConnection ?: run {
                             isSyncing = false
                             return@launch
@@ -1185,6 +1261,12 @@ class ListenTogetherManager @Inject constructor(
                         // Wait for player to be ready - monitor actual player state
                         var waitCount = 0
                         while (waitCount < 40) { // Max 2 seconds (40 * 50ms)
+                            // Check generation again while waiting
+                            if (currentTrackGeneration != generation) {
+                                Timber.tag(TAG).d("Generation changed while waiting for player ready - aborting sync for ${track.id}")
+                                isSyncing = false
+                                return@launch
+                            }
                             try {
                                 val player = connection.player
                                 if (player.playbackState == Player.STATE_READY) {

app/src/main/kotlin/com/metrolist/music/ui/component/Dialog.kt

@@ -18,6 +18,7 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyListScope
@@ -248,7 +249,9 @@ fun ListDialog(
         ) {
             Column(
                 horizontalAlignment = Alignment.CenterHorizontally,
-                modifier = modifier.padding(vertical = 24.dp),
+                modifier = modifier
+                    .padding(vertical = 24.dp)
+                    .imePadding(),
             ) {
                 LazyColumn(content = content)
             }

app/src/main/kotlin/com/metrolist/music/ui/screens/ListenTogetherScreen.kt

@@ -29,6 +29,7 @@ import androidx.compose.foundation.layout.asPaddingValues
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
@@ -232,7 +233,8 @@ fun ListenTogetherScreen(
         state = lazyListState,
         modifier = Modifier
             .fillMaxSize()
-            .background(MaterialTheme.colorScheme.background),
+            .background(MaterialTheme.colorScheme.background)
+            .imePadding(),
         contentPadding = PaddingValues(
             start = 16.dp,
             end = 16.dp,
@@ -353,6 +355,7 @@ fun ListenTogetherScreen(
                     isJoiningRoom = isJoiningRoom,
                     joinErrorMessage = joinErrorMessage,
                     waitingForApprovalText = waitingForApprovalText,
+                    bringIntoViewRequester = bringIntoViewRequester,
                     onCreateRoom = {
                         val username = usernameInput.takeIf { it.isNotBlank() } ?: savedUsername
                         val finalUsername = username.trim()
@@ -389,7 +392,7 @@ fun ListenTogetherScreen(
                     },
                     onFieldFocused = {
                         coroutineScope.launch {
-                            lazyListState.animateScrollToItem(3)
+                            bringIntoViewRequester.bringIntoView()
                         }
                     }
                 )
@@ -1019,6 +1022,7 @@ private fun JoinCreateRoomSection(
     isJoiningRoom: Boolean,
     joinErrorMessage: String?,
     waitingForApprovalText: String,
+    bringIntoViewRequester: BringIntoViewRequester,
     onCreateRoom: () -> Unit,
     onJoinRoom: () -> Unit,
     onFieldFocused: () -> Unit = {}
@@ -1100,6 +1104,7 @@ private fun JoinCreateRoomSection(
                 ),
                 modifier = Modifier
                     .fillMaxWidth()
+                    .bringIntoViewRequester(bringIntoViewRequester)
                     .onFocusChanged { if (it.isFocused) onFieldFocused() }
             )