Clean up room and local participant between sessions (#196)

@@ -458,6 +458,10 @@ constructor(
         localParticipant.cleanup()
         localParticipant.cleanup()
         remoteParticipants.keys.toMutableSet()  // copy keys to avoid concurrent modifications.
         remoteParticipants.keys.toMutableSet()  // copy keys to avoid concurrent modifications.
             .forEach { sid -> handleParticipantDisconnect(sid) }
             .forEach { sid -> handleParticipantDisconnect(sid) }
+
+        sid = null
+        metadata = null
+        name = null
     }
     }
 
 
     private fun handleDisconnect(reason: DisconnectReason) {
     private fun handleDisconnect(reason: DisconnectReason) {

@@ -143,15 +143,19 @@ open class Participant(
 
 
     private fun Flow<Map<String, TrackPublication>>.trackUpdateFlow(): Flow<List<Pair<TrackPublication, Track?>>> {
     private fun Flow<Map<String, TrackPublication>>.trackUpdateFlow(): Flow<List<Pair<TrackPublication, Track?>>> {
         return flatMapLatest { videoTracks ->
         return flatMapLatest { videoTracks ->
-            combine(
-                videoTracks.values
-                    .map { trackPublication ->
-                        // Re-emit when track changes
-                        trackPublication::track.flow
-                            .map { trackPublication to trackPublication.track }
-                    }
-            ) { trackPubs ->
-                trackPubs.toList()
+            if (videoTracks.isEmpty()) {
+                flowOf(emptyList())
+            } else {
+                combine(
+                    videoTracks.values
+                        .map { trackPublication ->
+                            // Re-emit when track changes
+                            trackPublication::track.flow
+                                .map { trackPublication to trackPublication.track }
+                        }
+                ) { trackPubs ->
+                    trackPubs.toList()
+                }
             }
             }
         }
         }
     }
     }
@@ -309,6 +313,14 @@ open class Participant(
 
 
     internal open fun dispose() {
     internal open fun dispose() {
         scope.cancel()
         scope.cancel()
+
+        sid = ""
+        name = null
+        identity = null
+        metadata = null
+        participantInfo = null
+        permissions = null
+        connectionQuality = ConnectionQuality.UNKNOWN
     }
     }
 }
 }
 
 

@@ -16,6 +16,7 @@ import io.livekit.android.room.track.Track
 import io.livekit.android.util.flow
 import io.livekit.android.util.flow
 import io.livekit.android.util.toOkioByteString
 import io.livekit.android.util.toOkioByteString
 import junit.framework.Assert.assertEquals
 import junit.framework.Assert.assertEquals
+import junit.framework.Assert.assertNull
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.launch
 import org.junit.Assert
 import org.junit.Assert
@@ -290,8 +291,9 @@ class RoomMockE2ETest : MockE2ETest() {
         )
         )
         val events = eventCollector.stopCollecting()
         val events = eventCollector.stopCollecting()
 
 
-        Assert.assertEquals(1, events.size)
-        Assert.assertEquals(true, events[0] is RoomEvent.Disconnected)
+        assertEquals(1, events.size)
+        assertEquals(true, events[0] is RoomEvent.Disconnected)
+
     }
     }
 
 
     @Test
     @Test

@@ -16,7 +16,7 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.test.runTest
 import org.junit.Assert
 import org.junit.Assert
-import org.junit.Assert.assertEquals
+import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Rule
 import org.junit.Test
 import org.junit.Test
@@ -128,7 +128,7 @@ class RoomTest {
     }
     }
 
 
     @Test
     @Test
-    fun onDisconnect() = runTest {
+    fun onServerLeave() = runTest {
         connect()
         connect()
 
 
         val eventCollector = EventCollector(room.events, coroutineRule.scope)
         val eventCollector = EventCollector(room.events, coroutineRule.scope)
@@ -138,6 +138,32 @@ class RoomTest {
         assertEquals(1, events.size)
         assertEquals(1, events.size)
         assertEquals(true, events[0] is RoomEvent.Disconnected)
         assertEquals(true, events[0] is RoomEvent.Disconnected)
         assertEquals(DisconnectReason.SERVER_SHUTDOWN, (events[0] as RoomEvent.Disconnected).reason)
         assertEquals(DisconnectReason.SERVER_SHUTDOWN, (events[0] as RoomEvent.Disconnected).reason)
+
+        // Verify Room state
+        assertEquals(Room.State.DISCONNECTED, room.state)
+        assertNull(room.sid)
+        assertNull(room.metadata)
+        assertNull(room.name)
+    }
+
+    @Test
+    fun onDisconnect() = runTest {
+
+        connect()
+        val eventCollector = EventCollector(room.events, coroutineRule.scope)
+        room.disconnect()
+        val events = eventCollector.stopCollecting()
+
+        assertEquals(1, events.size)
+        assertEquals(true, events[0] is RoomEvent.Disconnected)
+        assertEquals(DisconnectReason.CLIENT_INITIATED, (events[0] as RoomEvent.Disconnected).reason)
+
+        // Verify Room state
+        assertEquals(Room.State.DISCONNECTED, room.state)
+        assertNull(room.sid)
+        assertNull(room.metadata)
+        assertNull(room.name)
+
     }
     }
 
 
     @Test
     @Test

+package io.livekit.android.room.participant
+
+import io.livekit.android.MockE2ETest
+import io.livekit.android.mock.MockAudioStreamTrack
+import io.livekit.android.room.SignalClientTest
+import io.livekit.android.room.track.LocalAudioTrack
+import io.livekit.android.util.toOkioByteString
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runCurrent
+import org.junit.Assert.*
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@ExperimentalCoroutinesApi
+@RunWith(RobolectricTestRunner::class)
+class LocalParticipantMockE2ETest : MockE2ETest() {
+
+    @Test
+    fun disconnectCleansLocalParticipant() = runTest {
+
+        connect()
+
+        val publishJob = launch {
+            room.localParticipant.publishAudioTrack(
+                LocalAudioTrack(
+                    "",
+                    MockAudioStreamTrack(id = SignalClientTest.LOCAL_TRACK_PUBLISHED.trackPublished.cid)
+                )
+            )
+        }
+        wsFactory.listener.onMessage(wsFactory.ws, SignalClientTest.LOCAL_TRACK_PUBLISHED.toOkioByteString())
+        publishJob.join()
+
+        room.disconnect()
+
+        assertEquals("", room.localParticipant.sid)
+        assertNull(room.localParticipant.name)
+        assertNull(room.localParticipant.identity)
+        assertNull(room.localParticipant.metadata)
+        assertNull(room.localParticipant.permissions)
+        assertNull(room.localParticipant.participantInfo)
+        assertFalse(room.localParticipant.isSpeaking)
+        assertEquals(ConnectionQuality.UNKNOWN, room.localParticipant.connectionQuality)
+
+        assertEquals(0, room.localParticipant.tracks.values.size)
+        assertEquals(0, room.localParticipant.audioTracks.size)
+        assertEquals(0, room.localParticipant.videoTracks.size)
+    }
+}

@@ -7,6 +7,7 @@ import io.livekit.android.room.track.TrackPublication
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.test.runTest
 import livekit.LivekitModels
 import livekit.LivekitModels
+import org.junit.Assert
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Before
@@ -117,6 +118,22 @@ class ParticipantTest {
         assertEquals(audioPublication, participant.audioTracks.first().first)
         assertEquals(audioPublication, participant.audioTracks.first().first)
     }
     }
 
 
+    @Test
+    fun dispose() = runTest {
+        val audioPublication = TrackPublication(TRACK_INFO, null, participant)
+        participant.addTrackPublication(audioPublication)
+
+        participant.dispose()
+        assertEquals("", participant.sid)
+        Assert.assertNull(participant.name)
+        Assert.assertNull(participant.identity)
+        Assert.assertNull(participant.metadata)
+        Assert.assertNull(participant.permissions)
+        Assert.assertNull(participant.participantInfo)
+        Assert.assertFalse(participant.isSpeaking)
+        assertEquals(ConnectionQuality.UNKNOWN, participant.connectionQuality)
+    }
+
     companion object {
     companion object {
         val INFO = LivekitModels.ParticipantInfo.newBuilder()
         val INFO = LivekitModels.ParticipantInfo.newBuilder()
             .setSid("sid")
             .setSid("sid")