Fix ConcurrentModificationException in RemoteVideoTrack (#413)

@@ -23,7 +23,11 @@ import io.livekit.android.events.TrackEvent
 import io.livekit.android.room.track.video.VideoSinkVisibility
 import io.livekit.android.room.track.video.VideoSinkVisibility
 import io.livekit.android.room.track.video.ViewVisibility
 import io.livekit.android.room.track.video.ViewVisibility
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LKLog
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
 import livekit.org.webrtc.RtpReceiver
 import livekit.org.webrtc.RtpReceiver
 import livekit.org.webrtc.VideoSink
 import livekit.org.webrtc.VideoSink
 import javax.inject.Named
 import javax.inject.Named
@@ -40,7 +44,8 @@ class RemoteVideoTrack(
 
 
     private var coroutineScope = CoroutineScope(dispatcher + SupervisorJob())
     private var coroutineScope = CoroutineScope(dispatcher + SupervisorJob())
     private val sinkVisibilityMap = mutableMapOf<VideoSink, VideoSinkVisibility>()
     private val sinkVisibilityMap = mutableMapOf<VideoSink, VideoSinkVisibility>()
-    private val visibilities = sinkVisibilityMap.values
+    private val visibilities
+        get() = sinkVisibilityMap.values
 
 
     /**
     /**
      * @suppress
      * @suppress
@@ -80,7 +85,9 @@ class RemoteVideoTrack(
     fun addRenderer(renderer: VideoSink, visibility: VideoSinkVisibility) {
     fun addRenderer(renderer: VideoSink, visibility: VideoSinkVisibility) {
         super.addRenderer(renderer)
         super.addRenderer(renderer)
         if (autoManageVideo) {
         if (autoManageVideo) {
+            synchronized(sinkVisibilityMap) {
                 sinkVisibilityMap[renderer] = visibility
                 sinkVisibilityMap[renderer] = visibility
+            }
             visibility.addObserver { _, _ -> recalculateVisibility() }
             visibility.addObserver { _, _ -> recalculateVisibility() }
             recalculateVisibility()
             recalculateVisibility()
         } else {
         } else {
@@ -90,7 +97,11 @@ class RemoteVideoTrack(
 
 
     override fun removeRenderer(renderer: VideoSink) {
     override fun removeRenderer(renderer: VideoSink) {
         super.removeRenderer(renderer)
         super.removeRenderer(renderer)
-        val visibility = sinkVisibilityMap.remove(renderer)
+
+        val visibility = synchronized(sinkVisibilityMap) {
+            sinkVisibilityMap.remove(renderer)
+        }
+
         visibility?.close()
         visibility?.close()
         if (autoManageVideo && visibility != null) {
         if (autoManageVideo && visibility != null) {
             recalculateVisibility()
             recalculateVisibility()
@@ -99,29 +110,40 @@ class RemoteVideoTrack(
 
 
     override fun stop() {
     override fun stop() {
         super.stop()
         super.stop()
+        synchronized(sinkVisibilityMap) {
             sinkVisibilityMap.values.forEach { it.close() }
             sinkVisibilityMap.values.forEach { it.close() }
             sinkVisibilityMap.clear()
             sinkVisibilityMap.clear()
         }
         }
+    }
 
 
     private fun hasVisibleSinks(): Boolean {
     private fun hasVisibleSinks(): Boolean {
+        synchronized(sinkVisibilityMap) {
             return visibilities.any { it.isVisible() }
             return visibilities.any { it.isVisible() }
         }
         }
+    }
 
 
     private fun largestVideoViewSize(): Dimensions {
     private fun largestVideoViewSize(): Dimensions {
         var maxWidth = 0
         var maxWidth = 0
         var maxHeight = 0
         var maxHeight = 0
+
+        synchronized(sinkVisibilityMap) {
             visibilities.forEach { visibility ->
             visibilities.forEach { visibility ->
                 val size = visibility.size()
                 val size = visibility.size()
                 maxWidth = max(maxWidth, size.width)
                 maxWidth = max(maxWidth, size.width)
                 maxHeight = max(maxHeight, size.height)
                 maxHeight = max(maxHeight, size.height)
             }
             }
-
+        }
         return Dimensions(maxWidth, maxHeight)
         return Dimensions(maxWidth, maxHeight)
     }
     }
 
 
     private fun recalculateVisibility() {
     private fun recalculateVisibility() {
-        val isVisible = hasVisibleSinks()
-        val newDimensions = largestVideoViewSize()
+        var isVisible: Boolean
+        var newDimensions: Dimensions
+
+        synchronized(sinkVisibilityMap) {
+            isVisible = hasVisibleSinks()
+            newDimensions = largestVideoViewSize()
+        }
 
 
         val eventsToPost = mutableListOf<TrackEvent>()
         val eventsToPost = mutableListOf<TrackEvent>()
         if (isVisible != lastVisibility) {
         if (isVisible != lastVisibility) {