Merge branch 'main' into dl/session_api

davidliu · web-flow · commit 57621fda0ab9 · 2025-11-17T02:26:19.000+09:00
diff --git a/.changeset/fix-camera-indicator-orphaned-tracks.md b/.changeset/fix-camera-indicator-orphaned-tracks.md
@@ -0,0 +1,5 @@
+---
+"client-sdk-android": patch
+---
+
+Fixed camera indicator remaining on after network disconnection by disposing orphaned tracks from failed reconnection attempts (#296)
diff --git a/.changeset/nasty-kids-fail.md b/.changeset/nasty-kids-fail.md
diff --git a/.changeset/sixty-baboons-yawn.md b/.changeset/sixty-baboons-yawn.md
diff --git a/.changeset/tough-rings-unite.md b/.changeset/tough-rings-unite.md
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,36 @@
 # client-sdk-android
 
+## 2.22.0
+
+### Minor Changes
+
+- Extract CameraXProvider and expose it. - [#754](https://github.com/livekit/client-sdk-android/pull/754) ([@KasemJaffer](https://github.com/KasemJaffer))
+
+### Patch Changes
+
+- Fix camera lookup to check physicalId - [#792](https://github.com/livekit/client-sdk-android/pull/792) ([@KasemJaffer](https://github.com/KasemJaffer))
+
+## 2.21.1
+
+### Patch Changes
+
+- #721 Fixed publisher negotiation race condition causing ICE timeouts. - [#789](https://github.com/livekit/client-sdk-android/pull/789) ([@adrian-niculescu](https://github.com/adrian-niculescu))
+
+## 2.21.0
+
+### Minor Changes
+
+- End to end encryption for data channels option - [#762](https://github.com/livekit/client-sdk-android/pull/762) ([@davidliu](https://github.com/davidliu))
+
+  - Added EncryptionType fields to DataReceived events and StreamInfo objects to indicate the
+    encryption status.
+
+- Add TokenSource implementation for use with token servers - [#769](https://github.com/livekit/client-sdk-android/pull/769) ([@davidliu](https://github.com/davidliu))
+
+### Patch Changes
+
+- Increase RPC method max roundtrip time to 7s - [#775](https://github.com/livekit/client-sdk-android/pull/775) ([@davidliu](https://github.com/davidliu))
+
 ## 2.20.3
 
 ### Patch Changes
diff --git a/README.md b/README.md
@@ -47,7 +47,7 @@ LiveKit for Android is available as a Maven package.
 ```groovy title="build.gradle"
 ...
 dependencies {
-  def livekit_version = "2.20.3"
+  def livekit_version = "2.22.0"
 
   implementation "io.livekit:livekit-android:$livekit_version"
 
@@ -58,7 +58,7 @@ dependencies {
   implementation "io.livekit:livekit-android-track-processors:$livekit_version"
 
   // Snapshots of the latest development version are available at:
-  // implementation "io.livekit:livekit-android:2.20.4-SNAPSHOT"
+  // implementation "io.livekit:livekit-android:2.22.1-SNAPSHOT"
 }
 ```
 
diff --git a/gradle.properties b/gradle.properties
@@ -23,7 +23,7 @@ kotlin.code.style=official
 ###############################################################
 
 GROUP=io.livekit
-VERSION_NAME=2.20.4-SNAPSHOT
+VERSION_NAME=2.22.0
 
 POM_DESCRIPTION=LiveKit Android SDK, WebRTC Rooms
 
diff --git a/livekit-android-camerax/src/main/java/livekit/org/webrtc/CameraXHelper.kt b/livekit-android-camerax/src/main/java/livekit/org/webrtc/CameraXHelper.kt
@@ -16,16 +16,11 @@
 
 package livekit.org.webrtc
 
-import android.content.Context
 import android.hardware.camera2.CameraManager
 import androidx.camera.camera2.interop.ExperimentalCamera2Interop
 import androidx.camera.core.UseCase
-import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
-import io.livekit.android.room.track.LocalVideoTrackOptions
 import io.livekit.android.room.track.video.CameraCapturerUtils
-import io.livekit.android.room.track.video.CameraCapturerUtils.findCamera
-import io.livekit.android.room.track.video.CameraEventsDispatchHandler
 
 class CameraXHelper {
     companion object {
@@ -44,41 +39,9 @@ class CameraXHelper {
         fun createCameraProvider(
             lifecycleOwner: LifecycleOwner,
             useCases: Array<out UseCase> = emptyArray(),
-        ) = object : CameraCapturerUtils.CameraProvider {
-
-            private var enumerator: CameraXEnumerator? = null
-
-            override val cameraVersion = 3
-
-            override fun provideEnumerator(context: Context): CameraXEnumerator =
-                enumerator ?: CameraXEnumerator(context, lifecycleOwner, useCases).also {
-                    enumerator = it
-                }
-
-            override fun provideCapturer(
-                context: Context,
-                options: LocalVideoTrackOptions,
-                eventsHandler: CameraEventsDispatchHandler,
-            ): VideoCapturer {
-                val enumerator = provideEnumerator(context)
-                val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
-
-                val targetDevice = enumerator.findCamera(options.deviceId, options.position)
-                val targetDeviceId = targetDevice?.deviceId
-
-                val targetVideoCapturer = enumerator.createCapturer(targetDeviceId, eventsHandler) as CameraXCapturer
-
-                return CameraXCapturerWithSize(
-                    targetVideoCapturer,
-                    cameraManager,
-                    targetDeviceId,
-                    eventsHandler,
-                )
-            }
-
-            override fun isSupported(context: Context): Boolean {
-                return Camera2Enumerator.isSupported(context) && lifecycleOwner.lifecycle.currentState.isAtLeast(Lifecycle.State.INITIALIZED)
-            }
+            cameraVersion: Int = 3,
+        ): CameraXProvider {
+            return CameraXProvider(lifecycleOwner, useCases, cameraVersion)
         }
 
         private fun getSupportedFormats(
diff --git a/livekit-android-camerax/src/main/java/livekit/org/webrtc/CameraXProvider.kt b/livekit-android-camerax/src/main/java/livekit/org/webrtc/CameraXProvider.kt
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2025 LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package livekit.org.webrtc
+
+import android.content.Context
+import android.hardware.camera2.CameraManager
+import androidx.camera.camera2.interop.ExperimentalCamera2Interop
+import androidx.camera.core.UseCase
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import io.livekit.android.room.track.LocalVideoTrackOptions
+import io.livekit.android.room.track.video.CameraCapturerUtils
+import io.livekit.android.room.track.video.CameraCapturerUtils.findCamera
+import io.livekit.android.room.track.video.CameraEventsDispatchHandler
+
+@ExperimentalCamera2Interop
+class CameraXProvider(
+    val lifecycleOwner: LifecycleOwner,
+    val useCases: Array<out UseCase> = emptyArray(),
+    override val cameraVersion: Int = 3,
+) : CameraCapturerUtils.CameraProvider {
+
+    var enumerator: CameraXEnumerator? = null
+        private set
+
+    override fun provideEnumerator(context: Context): CameraXEnumerator = enumerator ?: CameraXEnumerator(context, lifecycleOwner, useCases).also {
+        enumerator = it
+    }
+
+    override fun provideCapturer(
+        context: Context,
+        options: LocalVideoTrackOptions,
+        eventsHandler: CameraEventsDispatchHandler,
+    ): VideoCapturer {
+        val enumerator = provideEnumerator(context)
+        val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
+
+        val targetDevice = enumerator.findCamera(options.deviceId, options.position)
+        val targetDeviceId = targetDevice?.deviceId
+
+        val targetVideoCapturer = enumerator.createCapturer(targetDeviceId, eventsHandler) as CameraXCapturer
+
+        return CameraXCapturerWithSize(
+            targetVideoCapturer,
+            cameraManager,
+            targetDeviceId,
+            eventsHandler,
+        )
+    }
+
+    override fun isSupported(context: Context): Boolean {
+        return Camera2Enumerator.isSupported(context) && lifecycleOwner.lifecycle.currentState.isAtLeast(Lifecycle.State.INITIALIZED)
+    }
+}
diff --git a/livekit-android-camerax/src/main/java/livekit/org/webrtc/CameraXSession.kt b/livekit-android-camerax/src/main/java/livekit/org/webrtc/CameraXSession.kt
@@ -167,7 +167,12 @@ internal constructor(
 
                 // Select camera by ID
                 val cameraSelector = CameraSelector.Builder()
-                    .addCameraFilter { cameraInfo -> cameraInfo.filter { Camera2CameraInfo.from(it).cameraId == cameraDevice.deviceId } }
+                    .addCameraFilter { cameraInfo ->
+                        cameraInfo.filter {
+                            val cameraId = Camera2CameraInfo.from(it).cameraId
+                            cameraId == cameraDevice.deviceId || cameraId == cameraDevice.physicalId
+                        }
+                    }
                     .build()
 
                 try {
@@ -282,7 +287,10 @@ internal constructor(
     }
 
     private fun obtainCameraConfiguration() {
-        val camera = cameraProvider.availableCameraInfos.map { Camera2CameraInfo.from(it) }.first { it.cameraId == cameraDevice.deviceId }
+        val camera = cameraProvider.availableCameraInfos.map { Camera2CameraInfo.from(it) }
+            .first {
+                it.cameraId == cameraDevice.deviceId || it.cameraId == cameraDevice.physicalId
+            }
 
         cameraOrientation = camera.getCameraCharacteristic(CameraCharacteristics.SENSOR_ORIENTATION) ?: -1
         isCameraFrontFacing = camera.getCameraCharacteristic(CameraCharacteristics.LENS_FACING) == CameraMetadata.LENS_FACING_FRONT
diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt
@@ -208,6 +208,12 @@ internal constructor(
      */
     private var configurationLock = Mutex()
 
+    /**
+     * Prevents concurrent publisher negotiations which can cause ICE gathering
+     * race conditions and connection failures.
+     */
+    private val negotiatePublisherMutex = Mutex()
+
     init {
         client.listener = this
     }
@@ -671,7 +677,15 @@ internal constructor(
         hasPublished = true
 
         coroutineScope.launch {
-            publisher?.negotiate?.invoke(getPublisherOfferConstraints())
+            if (negotiatePublisherMutex.tryLock()) {
+                try {
+                    publisher?.negotiate?.invoke(getPublisherOfferConstraints())
+                } finally {
+                    negotiatePublisherMutex.unlock()
+                }
+            } else {
+                LKLog.v { "negotiatePublisher: skipping, negotiation already in progress" }
+            }
         }
     }
 
diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/participant/LocalParticipant.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/participant/LocalParticipant.kt
@@ -1098,6 +1098,9 @@ internal constructor(
         // Maximum amount of time it should ever take for an RPC request to reach the destination, and the ACK to come back
         // This is set to 7 seconds to account for various relay timeouts and retries in LiveKit Cloud that occur in rare cases
         val maxRoundTripLatency = 7.seconds
+        // Minimum allowed effective timeout to ensure the RPC lifecycle always has at least
+        // one second to complete, even after accounting for round-trip latency.
+        val minEffectiveTimeout = 1.seconds
 
         if (payload.byteLength() > RTCEngine.MAX_DATA_PACKET_SIZE) {
             throw RpcError.BuiltinRpcError.REQUEST_PAYLOAD_TOO_LARGE.create()
@@ -1111,13 +1114,14 @@ internal constructor(
         }
 
         val requestId = UUID.randomUUID().toString()
-
+        // Ensure the effective response timeout is not less than 1 second
+        val effectiveTimeout = (responseTimeout - maxRoundTripLatency).coerceAtLeast(minEffectiveTimeout)
         val result = publishRpcRequest(
             destinationIdentity = destinationIdentity,
             requestId = requestId,
             method = method,
             payload = payload,
-            responseTimeout = responseTimeout - maxRoundTripLatency,
+            responseTimeout = effectiveTimeout,
         )
 
         if (result.isFailure) {
@@ -1645,18 +1649,40 @@ internal constructor(
                 }
             }
         }
+
+        // Dispose tracks that were saved for republishing but never got republished.
+        // This happens when reconnection fails after prepareForFullReconnect() was called.
+        val republishesToDispose = republishes?.toList() ?: emptyList()
+        for (pub in republishesToDispose) {
+            val track = pub.track
+            if (track != null) {
+                try {
+                    track.stop()
+                } catch (e: Exception) {
+                    LKLog.d(e) { "Exception stopping republish track:" }
+                }
+
+                try {
+                    track.dispose()
+                } catch (e: Exception) {
+                    LKLog.d(e) { "Exception disposing republish track:" }
+                }
+            }
+        }
+        republishes = null
+
         try {
             defaultAudioTrack?.dispose()
-            defaultAudioTrack = null
         } catch (_: Exception) {
             // Possible double dispose, ignore.
         }
         try {
             defaultVideoTrack?.dispose()
-            defaultVideoTrack = null
         } catch (_: Exception) {
             // Possible double dispose, ignore.
         }
+        defaultAudioTrack = null
+        defaultVideoTrack = null
     }
 
     /**
diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/rpc/RpcManager.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/rpc/RpcManager.kt
@@ -79,6 +79,8 @@ interface RpcManager {
      * @param method The method name to call.
      * @param payload The payload to pass to the method.
      * @param responseTimeout Timeout for receiving a response after initial connection.
+     *      If a value less than 8s is provided, it will be automatically clamped to 8s
+     *      to ensure sufficient time for round-trip latency buffering.
      *      Defaults to 15 seconds.
      * @return The response payload.
      * @throws RpcError on failure. Details in [RpcError.message].
diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/track/video/CameraCapturerUtils.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/track/video/CameraCapturerUtils.kt
@@ -69,7 +69,7 @@ object CameraCapturerUtils {
      *
      * Picks CameraProvider of highest available version that is supported on device
      */
-    private fun getCameraProvider(context: Context): CameraProvider {
+    fun getCameraProvider(context: Context): CameraProvider {
         return cameraProviders
             .sortedByDescending { it.cameraVersion }
             .first { it.isSupported(context) }
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "client-sdk-android",
-  "version": "2.20.3",
+  "version": "2.22.0",
   "repository": "https://github.com/livekit/client-sdk-android.git",
   "license": "Apache License 2.0",
   "private": true,

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"client-sdk-android": patch
 +---
++
 +Fixed camera indicator remaining on after network disconnection by disposing orphaned tracks from failed reconnection attempts (#296)