android automatic track management

build.gradle

@@ -2,7 +2,7 @@
 
 buildscript {
     ext {
-        compose_version = '1.0.4'
+        compose_version = '1.0.5'
         kotlin_version = '1.5.31'
         java_version = JavaVersion.VERSION_1_8
         dokka_version = '1.5.0'

livekit-android-sdk/build.gradle

@@ -104,6 +104,7 @@ dependencies {
     implementation "androidx.core:core:${versions.androidx_core}"
     implementation "com.google.protobuf:protobuf-java:${versions.protobuf}"
     implementation "com.google.protobuf:protobuf-java-util:${versions.protobuf}"
+    implementation "androidx.compose.ui:ui:$compose_version"
 
     implementation 'com.google.dagger:dagger:2.38'
     kapt 'com.google.dagger:dagger-compiler:2.38'

livekit-android-sdk/src/main/java/io/livekit/android/ConnectOptions.kt

@@ -8,7 +8,18 @@ import org.webrtc.PeerConnection
 
 
 data class ConnectOptions(
+    /** Auto subscribe to room tracks upon connect, defaults to true */
     val autoSubscribe: Boolean = true,
+    /**
+     * Automatically manage quality of subscribed video tracks, subscribe to the
+     * an appropriate resolution based on the size of the video elements that tracks
+     * are attached to.
+     *
+     * Also observes the visibility of attached tracks and pauses receiving data
+     * if they are not visible.
+     */
+    val autoManageVideo: Boolean = false,
+
     val iceServers: List<PeerConnection.IceServer>? = null,
     val rtcConfig: PeerConnection.RTCConfiguration? = null,
     /**

livekit-android-sdk/src/main/java/io/livekit/android/LiveKit.kt

@@ -61,6 +61,7 @@ class LiveKit {
             options?.videoTrackPublishDefaults?.let {
                 room.localParticipant.videoTrackPublishDefaults = it
             }
+            room.autoManageVideo = options?.autoManageVideo ?: false
 
             if (options?.audio == true) {
                 val audioTrack = room.localParticipant.createAudioTrack()

livekit-android-sdk/src/main/java/io/livekit/android/events/BroadcastEventBus.kt

@@ -0,0 +1,22 @@
+package io.livekit.android.events
+
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.collect
+
+class BroadcastEventBus<T> : EventListenable<T> {
+    private val mutableEvents = MutableSharedFlow<T>()
+    override val events = mutableEvents.asSharedFlow()
+
+    suspend fun postEvent(event: T) {
+        mutableEvents.emit(event)
+    }
+
+    suspend fun postEvents(eventsToPost: Collection<T>) {
+        eventsToPost.forEach { event ->
+            mutableEvents.emit(event)
+        }
+    }
+
+    fun readOnly(): EventListenable<T> = this
+}

livekit-android-sdk/src/main/java/io/livekit/android/events/Event.kt

@@ -0,0 +1,3 @@
+package io.livekit.android.events
+
+sealed class Event

livekit-android-sdk/src/main/java/io/livekit/android/events/EventListenable.kt

@@ -0,0 +1,12 @@
+package io.livekit.android.events
+
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.collect
+
+interface EventListenable<out T> {
+    val events: SharedFlow<T>
+}
+
+suspend inline fun <T> EventListenable<T>.collect(crossinline action: suspend (value: T) -> Unit) {
+    return events.collect(action)
+}

livekit-android-sdk/src/main/java/io/livekit/android/events/TrackEvent.kt

@@ -0,0 +1,8 @@
+package io.livekit.android.events
+
+import io.livekit.android.room.track.Track
+
+sealed class TrackEvent : Event() {
+    class VisibilityChanged(val isVisible: Boolean) : TrackEvent()
+    class VideoDimensionsChanged(val newDimensions: Track.Dimensions) : TrackEvent()
+}

livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt

@@ -10,13 +10,16 @@ import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import io.livekit.android.ConnectOptions
 import io.livekit.android.Version
+import io.livekit.android.dagger.InjectionNames
 import io.livekit.android.renderer.TextureViewRenderer
 import io.livekit.android.room.participant.*
 import io.livekit.android.room.track.*
 import io.livekit.android.util.LKLog
+import kotlinx.coroutines.CoroutineDispatcher
 import livekit.LivekitModels
 import livekit.LivekitRtc
 import org.webrtc.*
+import javax.inject.Named
 
 class Room
 @AssistedInject
@@ -26,6 +29,8 @@ constructor(
     private val eglBase: EglBase,
     private val localParticipantFactory: LocalParticipant.Factory,
     private val defaultsManager: DefaultsManager,
+    @Named(InjectionNames.DISPATCHER_IO)
+    private val ioDispatcher: CoroutineDispatcher,
 ) : RTCEngine.Listener, ParticipantListener, ConnectivityManager.NetworkCallback() {
     init {
         engine.listener = this
@@ -52,6 +57,7 @@ constructor(
     var metadata: String? = null
         private set
 
+    var autoManageVideo: Boolean = false
     var audioTrackCaptureDefaults: LocalAudioTrackOptions by defaultsManager::audioTrackCaptureDefaults
     var audioTrackPublishDefaults: AudioTrackPublishDefaults by defaultsManager::audioTrackPublishDefaults
     var videoTrackCaptureDefaults: LocalVideoTrackOptions by defaultsManager::videoTrackCaptureDefaults
@@ -121,9 +127,9 @@ constructor(
         }
 
         participant = if (info != null) {
-            RemoteParticipant(engine.client, info)
+            RemoteParticipant(info, engine.client, ioDispatcher)
         } else {
-            RemoteParticipant(engine.client, sid, null)
+            RemoteParticipant(sid, null, engine.client, ioDispatcher)
         }
         participant.internalListener = this
         mutableRemoteParticipants[sid] = participant
@@ -282,7 +288,7 @@ constructor(
             trackSid = track.id()
         }
         val participant = getOrCreateRemoteParticipant(participantSid)
-        participant.addSubscribedMediaTrack(track, trackSid!!)
+        participant.addSubscribedMediaTrack(track, trackSid!!, autoManageVideo)
     }
 
     /**

livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt

@@ -26,13 +26,15 @@ import org.webrtc.PeerConnection
 import org.webrtc.SessionDescription
 import javax.inject.Inject
 import javax.inject.Named
+import javax.inject.Singleton
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.suspendCoroutine
 
 /**
  * SignalClient to LiveKit WS servers
  * @suppress
  */
+@Singleton
 class SignalClient
 @Inject
 constructor(
@@ -288,11 +290,26 @@ constructor(
         sendRequest(request)
     }
 
-    fun sendUpdateTrackSettings(sid: String, disabled: Boolean, videoQuality: LivekitRtc.VideoQuality) {
+    fun sendUpdateTrackSettings(
+        sid: String,
+        disabled: Boolean,
+        videoDimensions: Track.Dimensions?,
+        videoQuality: LivekitRtc.VideoQuality?,
+    ) {
         val trackSettings = LivekitRtc.UpdateTrackSettings.newBuilder()
             .addTrackSids(sid)
             .setDisabled(disabled)
-            .setQuality(videoQuality)
+            .apply {
+                if(videoDimensions != null) {
+                    width = videoDimensions.width
+                    height = videoDimensions.height
+                } else if(videoQuality != null) {
+                    quality = videoQuality
+                } else {
+                    // default to HIGH
+                    quality = LivekitRtc.VideoQuality.HIGH
+                }
+            }
 
          val request = LivekitRtc.SignalRequest.newBuilder()
             .setTrackSetting(trackSettings)

livekit-android-sdk/src/main/java/io/livekit/android/room/participant/RemoteParticipant.kt

@@ -4,6 +4,7 @@ import io.livekit.android.room.SignalClient
 import io.livekit.android.room.track.*
 import io.livekit.android.util.CloseableCoroutineScope
 import io.livekit.android.util.LKLog
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -13,14 +14,24 @@ import org.webrtc.MediaStreamTrack
 import org.webrtc.VideoTrack
 
 class RemoteParticipant(
-    val signalClient: SignalClient,
     sid: String,
     identity: String? = null,
+    val signalClient: SignalClient,
+    private val ioDispatcher: CoroutineDispatcher,
 ) : Participant(sid, identity) {
     /**
      * @suppress
      */
-    constructor(signalClient: SignalClient, info: LivekitModels.ParticipantInfo) : this(signalClient, info.sid, info.identity) {
+    constructor(
+        info: LivekitModels.ParticipantInfo,
+        signalClient: SignalClient,
+        ioDispatcher: CoroutineDispatcher
+    ) : this(
+        info.sid,
+        info.identity,
+        signalClient,
+        ioDispatcher,
+    ) {
         updateFromInfo(info)
     }
 
@@ -43,7 +54,11 @@ class RemoteParticipant(
             var publication = getTrackPublication(trackSid)
 
             if (publication == null) {
-                publication = RemoteTrackPublication(trackInfo, participant = this)
+                publication = RemoteTrackPublication(
+                    trackInfo,
+                    participant = this,
+                    ioDispatcher = ioDispatcher
+                )
 
                 newTrackPublications[trackSid] = publication
                 addTrackPublication(publication)
@@ -71,11 +86,21 @@ class RemoteParticipant(
     /**
      * @suppress
      */
-    fun addSubscribedMediaTrack(mediaTrack: MediaStreamTrack, sid: String, triesLeft: Int = 20) {
+    fun addSubscribedMediaTrack(
+        mediaTrack: MediaStreamTrack,
+        sid: String,
+        autoManageVideo: Boolean = false,
+        triesLeft: Int = 20
+    ) {
         val publication = getTrackPublication(sid)
         val track: Track = when (val kind = mediaTrack.kind()) {
             KIND_AUDIO -> AudioTrack(rtcTrack = mediaTrack as AudioTrack, name = "")
-            KIND_VIDEO -> VideoTrack(rtcTrack = mediaTrack as VideoTrack, name = "")
+            KIND_VIDEO -> RemoteVideoTrack(
+                rtcTrack = mediaTrack as VideoTrack,
+                name = "",
+                autoManageVideo = autoManageVideo,
+                dispatcher = ioDispatcher
+            )
             else -> throw TrackException.InvalidTrackTypeException("invalid track type: $kind")
         }
 
@@ -90,7 +115,7 @@ class RemoteParticipant(
             } else {
                 coroutineScope.launch {
                     delay(150)
-                    addSubscribedMediaTrack(mediaTrack, sid, triesLeft - 1)
+                    addSubscribedMediaTrack(mediaTrack, sid, autoManageVideo, triesLeft - 1)
                 }
             }
             return