Improve lobby navigation flow

app/src/main/java/com/github/feelbeatapp/androidclient/game/datastreaming/Game.kt

@@ -15,4 +15,8 @@ class Game(private var gameState: GameState) {
     fun removePlayer(playerId: String) {
         gameState = gameState.copy(players = gameState.players.filter { it.id != playerId })
     }
+
+    fun setAdmin(playerId: String) {
+        gameState = gameState.copy(adminId = playerId)
+    }
 }

app/src/main/java/com/github/feelbeatapp/androidclient/game/datastreaming/GameDataStreamer.kt

@@ -1,10 +1,13 @@
 package com.github.feelbeatapp.androidclient.game.datastreaming
 
 import com.github.feelbeatapp.androidclient.game.model.GameState
+import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.flow.StateFlow
 
 interface GameDataStreamer {
-    suspend fun joinRoom(roomId: String)
+    suspend fun joinRoom(roomId: String): Deferred<Unit>
+
+    fun leaveRoom()
 
     fun gameStateFlow(): StateFlow<GameState?>
 }

app/src/main/java/com/github/feelbeatapp/androidclient/game/datastreaming/RemoteGameDataStreamer.kt

@@ -8,31 +8,64 @@ import com.github.feelbeatapp.androidclient.game.datastreaming.messages.server.P
 import com.github.feelbeatapp.androidclient.game.datastreaming.messages.server.ServerMessageType
 import com.github.feelbeatapp.androidclient.game.model.GameState
 import com.github.feelbeatapp.androidclient.infra.error.ErrorCode
+import com.github.feelbeatapp.androidclient.infra.error.ErrorReceiver
 import com.github.feelbeatapp.androidclient.infra.error.FeelBeatException
 import com.github.feelbeatapp.androidclient.infra.network.NetworkClient
 import javax.inject.Inject
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.jsonPrimitive
 
-class RemoteGameDataStreamer @Inject constructor(private val networkClient: NetworkClient) :
+class RemoteGameDataStreamer
+@Inject
+constructor(private val networkClient: NetworkClient, private val errorReceiver: ErrorReceiver) :
     GameDataStreamer {
     private var game: Game? = null
     private var gameStateFlow = MutableStateFlow<GameState?>(null)
     private var scope: CoroutineScope? = null
 
-    override suspend fun joinRoom(roomId: String) {
+    override suspend fun joinRoom(roomId: String): Deferred<Unit> =
+        withContext(Dispatchers.IO) {
+            leaveRoom()
+            val newScope = CoroutineScope(Dispatchers.IO)
+            scope = newScope
+
+            val connectionEstablished = CompletableDeferred<Unit>()
+
+            newScope.launch {
+                try {
+                    networkClient.connect("/ws/$roomId").collect {
+                        if (!connectionEstablished.isCompleted) {
+                            connectionEstablished.complete(Unit)
+                        }
+                        processMessage(it)
+                    }
+                } catch (e: FeelBeatException) {
+                    if (!connectionEstablished.isCompleted) {
+                        connectionEstablished.completeExceptionally(e)
+                    }
+                    errorReceiver.submitError(e)
+                } finally {
+                    connectionEstablished.completeExceptionally(CancellationException())
+                }
+            }
+
+            return@withContext connectionEstablished
+        }
+
+    override fun leaveRoom() {
         scope?.cancel()
-        val newScope = CoroutineScope(Dispatchers.IO)
-        scope = newScope
-        newScope.launch { networkClient.connect("/ws/$roomId").collect { processMessage(it) } }
         scope = null
         gameStateFlow.value = null
     }
@@ -53,7 +86,9 @@ class RemoteGameDataStreamer @Inject constructor(private val networkClient: Netw
                     gameStateFlow.value = game?.gameState()
                 }
                 ServerMessageType.PLAYER_LEFT.name -> {
-                    game?.removePlayer(Json.decodeFromString<PlayerLeftMessage>(content).payload)
+                    val payload = Json.decodeFromString<PlayerLeftMessage>(content).payload
+                    game?.removePlayer(payload.left)
+                    game?.setAdmin(payload.admin)
                     gameStateFlow.value = game?.gameState()
                 }
                 else -> Log.w("RemoteGameDataStreamer", "Received unexpected message: $content")
@@ -71,6 +106,7 @@ class RemoteGameDataStreamer @Inject constructor(private val networkClient: Netw
                     playlistName = initialState.playlist.name,
                     playlistImageUrl = initialState.playlist.imageUrl,
                     adminId = initialState.admin,
+                    me = initialState.me,
                     players = initialState.players,
                     songs = initialState.playlist.songs.map { it.toSongModel() },
                 )

app/src/main/java/com/github/feelbeatapp/androidclient/game/datastreaming/messages/server/PlayerLeftMessage.kt

@@ -7,5 +7,11 @@ import kotlinx.serialization.Serializable
 @SerialName("PLAYER_LEFT")
 data class PlayerLeftMessage(
     override val type: String = ServerMessageType.PLAYER_LEFT.name,
-    val payload: String,
+    val payload: PlayerLeftPayload,
 ) : ServerMessage()
+
+@Serializable
+data class PlayerLeftPayload(
+    val left: String,
+    val admin: String
+)

app/src/main/java/com/github/feelbeatapp/androidclient/game/model/GameState.kt

@@ -5,6 +5,7 @@ data class GameState(
     val playlistName: String,
     val playlistImageUrl: String,
     val adminId: String,
+    val me: String,
     val players: List<Player>,
     val songs: List<Song>,
 )

app/src/main/java/com/github/feelbeatapp/androidclient/infra/error/ErrorHandler.kt

@@ -6,7 +6,7 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 
 class ErrorHandler @Inject constructor() : ErrorEmitter, ErrorReceiver {
-    private val _errors = MutableSharedFlow<FeelBeatException>()
+    private val _errors = MutableSharedFlow<FeelBeatException>(extraBufferCapacity = 32)
     override val errors = _errors.asSharedFlow()
 
     override suspend fun submitError(exception: FeelBeatException) {

app/src/main/java/com/github/feelbeatapp/androidclient/infra/network/WebsocketClient.kt

@@ -15,14 +15,15 @@ import io.ktor.websocket.WebSocketSession
 import io.ktor.websocket.close
 import io.ktor.websocket.readText
 import io.ktor.websocket.send
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.catch
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.flow.onCompletion
 import java.util.ArrayDeque
 import java.util.Queue
 import javax.inject.Inject
 import javax.inject.Named
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
 
 /** Websocket implementation of communication with FeelBeat server */
 class WebsocketClient
@@ -60,10 +61,10 @@ constructor(
                     }
                 }
             }
+            .flowOn(Dispatchers.IO)
             .catch { e ->
                 throw FeelBeatException(ErrorCode.FEELBEAT_SERVER_FAILED_TO_JOIN_ROOM, e)
             }
-            .onCompletion { Log.d("Look", "completed") }
     }
 
     override suspend fun disconnect() {

app/src/main/java/com/github/feelbeatapp/androidclient/ui/app/AppViewModel.kt

@@ -5,17 +5,18 @@ import androidx.compose.material3.SnackbarHostState
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.github.feelbeatapp.androidclient.api.spotify.SpotifyAPI
+import com.github.feelbeatapp.androidclient.game.datastreaming.GameDataStreamer
 import com.github.feelbeatapp.androidclient.infra.auth.AuthManager
 import com.github.feelbeatapp.androidclient.infra.error.ErrorEmitter
 import com.github.feelbeatapp.androidclient.infra.error.FeelBeatException
 import com.github.feelbeatapp.androidclient.infra.error.FeelBeatServerException
 import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
+import javax.inject.Inject
 
 data class PlayerIdentity(val name: String, val imageUrl: String)
 
@@ -27,6 +28,7 @@ constructor(
     private val authManager: AuthManager,
     private val spotifyAPI: SpotifyAPI,
     private val errorEmitter: ErrorEmitter,
+    private val gameDataStreamer: GameDataStreamer
 ) : ViewModel() {
     private val _playerIdentity = MutableStateFlow<PlayerIdentity?>(null)
     val playerIdentity = _playerIdentity.asStateFlow()
@@ -67,5 +69,6 @@ constructor(
 
     fun logout() {
         authManager.logout()
+        gameDataStreamer.leaveRoom()
     }
 }

app/src/main/java/com/github/feelbeatapp/androidclient/ui/app/components/SongCard.kt

@@ -62,7 +62,7 @@ fun SongCard(
                 verticalAlignment = Alignment.CenterVertically,
                 modifier = Modifier.fillMaxWidth().padding(10.dp, 0.dp),
             ) {
-                Column(verticalArrangement = Arrangement.Center) {
+                Column(verticalArrangement = Arrangement.Center, modifier = Modifier.weight(1f)) {
                     Text(title, style = MaterialTheme.typography.titleMedium)
 
                     Text(artist, style = MaterialTheme.typography.titleSmall)

app/src/main/java/com/github/feelbeatapp/androidclient/ui/app/home/HomeScreen.kt

@@ -21,14 +21,14 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.pulltorefresh.PullToRefreshBox
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.github.feelbeatapp.androidclient.R
 import com.github.feelbeatapp.androidclient.api.feelbeat.responses.RoomListViewResponse
 import com.github.feelbeatapp.androidclient.ui.app.components.RoomCard
@@ -39,10 +39,13 @@ fun HomeScreen(
     onNewRoom: () -> Unit,
     homeViewModel: HomeViewModel = hiltViewModel(),
 ) {
-    val rooms by homeViewModel.rooms.collectAsState()
-    val loading by homeViewModel.loading.collectAsState()
+    val rooms by homeViewModel.rooms.collectAsStateWithLifecycle()
+    val loading by homeViewModel.loading.collectAsStateWithLifecycle()
 
-    LaunchedEffect(null) { homeViewModel.loadRooms() }
+    LaunchedEffect(null) {
+        homeViewModel.leaveRoom()
+        homeViewModel.loadRooms()
+    }
 
     Box(modifier = Modifier.fillMaxSize()) {
         Column(modifier = Modifier.fillMaxSize()) {
@@ -106,7 +109,7 @@ fun RoomList(
     modifier: Modifier = Modifier,
 ) {
     PullToRefreshBox(isRefreshing = isRefreshing, onRefresh = onRefresh, modifier = modifier) {
-        LazyColumn(Modifier) {
+        LazyColumn(modifier = Modifier.fillMaxSize()) {
             items(items) { ListItem({ RoomCard(room = it, onClick = { onRoomSelect(it.id) }) }) }
         }
     }

app/src/main/java/com/github/feelbeatapp/androidclient/ui/app/home/HomeViewModel.kt

@@ -2,29 +2,36 @@ package com.github.feelbeatapp.androidclient.ui.app.home
 
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.github.feelbeatapp.androidclient.api.feelbeat.FeelBeatApi
+import com.github.feelbeatapp.androidclient.api.feelbeat.responses.RoomListViewResponse
+import com.github.feelbeatapp.androidclient.game.datastreaming.GameDataStreamer
 import com.github.feelbeatapp.androidclient.infra.error.ErrorReceiver
 import com.github.feelbeatapp.androidclient.infra.error.FeelBeatException
-import com.github.feelbeatapp.androidclient.api.feelbeat.responses.RoomListViewResponse
-import com.github.feelbeatapp.androidclient.api.feelbeat.FeelBeatApi
 import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
+import javax.inject.Inject
 
 @HiltViewModel
 class HomeViewModel
 @Inject
-constructor(private val feelBeatApi: FeelBeatApi, private val errorReceiver: ErrorReceiver) :
-    ViewModel() {
+constructor(
+    private val feelBeatApi: FeelBeatApi,
+    private val errorReceiver: ErrorReceiver,
+    private val gameDataStreamer: GameDataStreamer,
+) : ViewModel() {
     private val _rooms = MutableStateFlow<List<RoomListViewResponse>>(listOf())
     val rooms: StateFlow<List<RoomListViewResponse>> = _rooms.asStateFlow()
 
     private val _loading = MutableStateFlow(false)
     val loading = _loading.asStateFlow()
 
-    @SuppressWarnings("MagicNumber")
+    fun leaveRoom() {
+        gameDataStreamer.leaveRoom()
+    }
+
     fun loadRooms() {
         _loading.value = true
         viewModelScope.launch {

app/src/main/java/com/github/feelbeatapp/androidclient/ui/app/lobby/LobbyBottomBar.kt → app/src/main/java/com/github/feelbeatapp/androidclient/ui/app/lobby/components/LobbyBottomBar.kt

@@ -1,4 +1,4 @@
-package com.github.feelbeatapp.androidclient.ui.app.lobby
+package com.github.feelbeatapp.androidclient.ui.app.lobby.components
 
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Home

app/src/main/java/com/github/feelbeatapp/androidclient/ui/app/lobby/lobbyhome/LobbyHomeScreen.kt

@@ -20,8 +20,7 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.layout.ContentScale
@@ -31,27 +30,19 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coil3.compose.AsyncImage
 import com.github.feelbeatapp.androidclient.R
 import com.github.feelbeatapp.androidclient.ui.app.components.PlayerCard
+import com.github.feelbeatapp.androidclient.ui.loading.LoadingScreen
 
 @OptIn(ExperimentalLayoutApi::class)
 @Composable
-fun LobbyHomeScreen(
-    roomId: String,
-    onPlay: () -> Unit,
-    viewModel: LobbyHomeViewModel = hiltViewModel(),
-) {
-    val lobbyState = viewModel.lobbyHomeState.collectAsState().value
-
-    LaunchedEffect(roomId) {
-        if (roomId != lobbyState.currentRoomId) {
-            viewModel.joinRoom(roomId)
-        }
-    }
+fun LobbyHomeScreen(onPlay: () -> Unit, viewModel: LobbyHomeViewModel = hiltViewModel()) {
+    val lobbyState by viewModel.lobbyHomeState.collectAsStateWithLifecycle()
 
     if (lobbyState.currentRoomId == null) {
-        Text("Loading ")
+        LoadingScreen()
         return
     }
 
@@ -109,5 +100,5 @@ fun LobbyHomeScreen(
 @Preview(showBackground = true)
 @Composable
 fun PreviewAcceptScreen() {
-    LobbyHomeScreen("Room id", {})
+    LobbyHomeScreen({})
 }

app/src/main/java/com/github/feelbeatapp/androidclient/ui/app/lobby/lobbyhome/LobbyHomeViewModel.kt

@@ -6,11 +6,11 @@ import com.github.feelbeatapp.androidclient.game.datastreaming.GameDataStreamer
 import com.github.feelbeatapp.androidclient.game.model.GameState
 import com.github.feelbeatapp.androidclient.game.model.Player
 import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import javax.inject.Inject
 
 data class LobbyHomeState(
     val currentRoomId: String? = null,
@@ -45,9 +45,4 @@ class LobbyHomeViewModel @Inject constructor(private val gameDataStreamer: GameD
             _lobbyHomeState.update { it.copy(currentRoomId = null) }
         }
     }
-
-    suspend fun joinRoom(roomId: String) {
-        _lobbyHomeState.update { it.copy(currentRoomId = null) }
-        gameDataStreamer.joinRoom(roomId)
-    }
 }