Refactor and enable switching between cameras using physical id. (#676)

* Refactor and enable switching between cameras using physical id.

* Override cameraName

* Rename unused arguments in predicate

* Update documentation

* Add changeset

* Move camera lookup to CameraXSession

* Override isBackFacing and isFrontFacing

* update byte buddy to support java 21

* Refactor to fix unit tests

* Run spotlessApply

* Run spotlessApply on all plugins

* cleanup

---------

Co-authored-by: davidliu <davidliu@deviange.net>

Author: KasemJaffer

.changeset/gorgeous-ligers-suffer.md

@@ -0,0 +1,5 @@
+---
+"client-sdk-android": patch
+---
+
+Fix switchCamera not working if the camera id is physical id

gradle/libs.versions.toml

@@ -94,6 +94,7 @@ mockito-core = { module = "org.mockito:mockito-core", version = "4.11.0" }
 mockito-kotlin = { module = "org.mockito.kotlin:mockito-kotlin", version = "4.1.0" }
 #noinspection GradleDependency
 mockito-inline = { module = "org.mockito:mockito-inline", version = "4.11.0" }
+byte-buddy = { module = "net.bytebuddy:byte-buddy", version = "1.14.3" }
 
 robolectric = { module = "org.robolectric:robolectric", version = "4.14.1" }
 turbine = { module = "app.cash.turbine:turbine", version = "1.0.0" }

livekit-android-camerax/src/main/java/livekit/org/webrtc/CameraXCapturer.kt

@@ -32,13 +32,12 @@ import kotlinx.coroutines.flow.StateFlow
 
 @ExperimentalCamera2Interop
 internal class CameraXCapturer(
-    context: Context,
+    enumerator: CameraXEnumerator,
     private val lifecycleOwner: LifecycleOwner,
     cameraName: String?,
     eventsHandler: CameraVideoCapturer.CameraEventsHandler?,
     private val useCases: Array<out UseCase> = emptyArray(),
-    var physicalCameraId: String? = null,
-) : CameraCapturer(cameraName, eventsHandler, CameraXEnumerator(context, lifecycleOwner)) {
+) : CameraCapturer(cameraName, eventsHandler, enumerator) {
 
     @FlowObservable
     @get:FlowObservable
@@ -94,7 +93,6 @@ internal class CameraXCapturer(
             height,
             framerate,
             useCases,
-            physicalCameraId,
         )
     }
 }

livekit-android-camerax/src/main/java/livekit/org/webrtc/CameraXEnumerator.kt

@@ -35,14 +35,40 @@ class CameraXEnumerator(
     context: Context,
     private val lifecycleOwner: LifecycleOwner,
     private val useCases: Array<out UseCase> = emptyArray(),
-    var physicalCameraId: String? = null,
 ) : Camera2Enumerator(context) {
 
+    override fun getDeviceNames(): Array<out String?> {
+        val cm = cameraManager!!
+        val availableCameraIds = ArrayList<String>()
+        for (id in cm.cameraIdList) {
+            availableCameraIds.add(id)
+            if (VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                val characteristics = cm.getCameraCharacteristics(id)
+                for (physicalId in characteristics.physicalCameraIds) {
+                    availableCameraIds.add(physicalId)
+                }
+            }
+        }
+        return availableCameraIds.toTypedArray()
+    }
+
+    override fun isBackFacing(deviceName: String?): Boolean {
+        val characteristics = cameraManager!!.getCameraCharacteristics(deviceName!!)
+        val lensFacing = characteristics.get(CameraCharacteristics.LENS_FACING)
+        return lensFacing == CameraCharacteristics.LENS_FACING_BACK
+    }
+
+    override fun isFrontFacing(deviceName: String?): Boolean {
+        val characteristics = cameraManager!!.getCameraCharacteristics(deviceName!!)
+        val lensFacing = characteristics.get(CameraCharacteristics.LENS_FACING)
+        return lensFacing == CameraCharacteristics.LENS_FACING_FRONT
+    }
+
     override fun createCapturer(
         deviceName: String?,
         eventsHandler: CameraVideoCapturer.CameraEventsHandler?,
     ): CameraVideoCapturer {
-        return CameraXCapturer(context, lifecycleOwner, deviceName, eventsHandler, useCases, physicalCameraId)
+        return CameraXCapturer(this, lifecycleOwner, deviceName, eventsHandler, useCases)
     }
 
     companion object {

livekit-android-camerax/src/main/java/livekit/org/webrtc/CameraXHelper.kt

@@ -18,7 +18,6 @@ package livekit.org.webrtc
 
 import android.content.Context
 import android.hardware.camera2.CameraManager
-import android.os.Build
 import androidx.camera.camera2.interop.ExperimentalCamera2Interop
 import androidx.camera.core.UseCase
 import androidx.lifecycle.Lifecycle
@@ -63,45 +62,23 @@ class CameraXHelper {
             ): VideoCapturer {
                 val enumerator = provideEnumerator(context)
                 val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
-                val deviceId = options.deviceId
-                var targetDeviceName: String? = null
-                if (deviceId != null) {
-                    targetDeviceName = findCameraById(cameraManager, deviceId)
-                }
-                if (targetDeviceName == null) {
-                    // Fallback to enumerator.findCamera which can't find camera by physical id but it will choose the closest one.
-                    targetDeviceName = enumerator.findCamera(deviceId, options.position)
-                }
-                val targetVideoCapturer = enumerator.createCapturer(targetDeviceName, eventsHandler) as CameraXCapturer
+
+                val targetDevice = enumerator.findCamera(options.deviceId, options.position)
+                val targetDeviceId = targetDevice?.deviceId
+
+                val targetVideoCapturer = enumerator.createCapturer(targetDeviceId, eventsHandler) as CameraXCapturer
 
                 return CameraXCapturerWithSize(
                     targetVideoCapturer,
                     cameraManager,
-                    targetDeviceName,
+                    targetDeviceId,
                     eventsHandler,
                 )
             }
 
             override fun isSupported(context: Context): Boolean {
                 return Camera2Enumerator.isSupported(context) && lifecycleOwner.lifecycle.currentState.isAtLeast(Lifecycle.State.INITIALIZED)
             }
-
-            private fun findCameraById(cameraManager: CameraManager, deviceId: String): String? {
-                for (id in cameraManager.cameraIdList) {
-                    if (id == deviceId) return id // This means the provided id is logical id.
-
-                    val characteristics = cameraManager.getCameraCharacteristics(id)
-                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-                        val ids = characteristics.physicalCameraIds
-                        if (ids.contains(deviceId)) {
-                            // This means the provided id is physical id.
-                            enumerator?.physicalCameraId = deviceId
-                            return id // This is its logical id.
-                        }
-                    }
-                }
-                return null
-            }
         }
 
         private fun getSupportedFormats(

livekit-android-camerax/src/main/java/livekit/org/webrtc/CameraXSession.kt

@@ -18,13 +18,15 @@ package livekit.org.webrtc
 
 import android.content.Context
 import android.hardware.camera2.CameraCharacteristics
+import android.hardware.camera2.CameraManager
 import android.hardware.camera2.CameraMetadata
 import android.hardware.camera2.CameraMetadata.CONTROL_VIDEO_STABILIZATION_MODE_OFF
 import android.hardware.camera2.CameraMetadata.CONTROL_VIDEO_STABILIZATION_MODE_ON
 import android.hardware.camera2.CameraMetadata.LENS_OPTICAL_STABILIZATION_MODE_OFF
 import android.hardware.camera2.CameraMetadata.LENS_OPTICAL_STABILIZATION_MODE_ON
 import android.hardware.camera2.CaptureRequest
 import android.os.Build
+import android.os.Build.VERSION
 import android.os.Handler
 import android.util.Range
 import android.util.Size
@@ -62,7 +64,6 @@ internal constructor(
     private val height: Int,
     private val frameRate: Int,
     private val useCases: Array<out UseCase> = emptyArray(),
-    var physicalCameraId: String? = null,
 ) : CameraSession {
 
     private var state = SessionState.RUNNING
@@ -106,6 +107,13 @@ internal constructor(
         }
     }
 
+    private val cameraDevice: CameraDeviceId
+        get() {
+            val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
+            return findCamera(cameraManager, cameraId)
+                ?: throw IllegalArgumentException("Camera ID $cameraId not found")
+        }
+
     init {
         cameraThreadHandler.post {
             start()
@@ -160,7 +168,7 @@ internal constructor(
 
                 // Select camera by ID
                 val cameraSelector = CameraSelector.Builder()
-                    .addCameraFilter { cameraInfo -> cameraInfo.filter { Camera2CameraInfo.from(it).cameraId == cameraId } }
+                    .addCameraFilter { cameraInfo -> cameraInfo.filter { Camera2CameraInfo.from(it).cameraId == cameraDevice.deviceId } }
                     .build()
 
                 try {
@@ -209,7 +217,7 @@ internal constructor(
     private fun <T> ExtendableBuilder<T>.applyCameraSettings(): ExtendableBuilder<T> {
         val cameraExtender = Camera2Interop.Extender(this)
 
-        physicalCameraId?.let { physicalId ->
+        cameraDevice.physicalId?.let { physicalId ->
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                 cameraExtender.setPhysicalCameraId(physicalId)
             }
@@ -275,7 +283,7 @@ internal constructor(
     }
 
     private fun obtainCameraConfiguration() {
-        val camera = cameraProvider.availableCameraInfos.map { Camera2CameraInfo.from(it) }.first { it.cameraId == cameraId }
+        val camera = cameraProvider.availableCameraInfos.map { Camera2CameraInfo.from(it) }.first { it.cameraId == cameraDevice.deviceId }
 
         cameraOrientation = camera.getCameraCharacteristic(CameraCharacteristics.SENSOR_ORIENTATION) ?: -1
         isCameraFrontFacing = camera.getCameraCharacteristic(CameraCharacteristics.LENS_FACING) == CameraMetadata.LENS_FACING_FRONT
@@ -326,6 +334,30 @@ internal constructor(
         return (cameraOrientation + rotation) % 360
     }
 
+    private data class CameraDeviceId(val deviceId: String, val physicalId: String?)
+
+    private fun findCamera(
+        cameraManager: CameraManager,
+        deviceId: String,
+    ): CameraDeviceId? {
+        for (id in cameraManager.cameraIdList) {
+            // First check if deviceId is a direct logical camera ID
+            if (id == deviceId) return CameraDeviceId(id, null)
+
+            // Then check if deviceId is a physical camera ID in a logical camera
+            if (VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                val characteristic = cameraManager.getCameraCharacteristics(id)
+
+                for (physicalId in characteristic.physicalCameraIds) {
+                    if (deviceId == physicalId) {
+                        return CameraDeviceId(id, physicalId)
+                    }
+                }
+            }
+        }
+        return null
+    }
+
     companion object {
         private const val TAG = "CameraXSession"
         private val cameraXStartTimeMsHistogram = Histogram.createCounts("WebRTC.Android.CameraX.StartTimeMs", 1, 10000, 50)

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023-2024 LiveKit, Inc.
+ * Copyright 2023-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.
@@ -27,9 +27,9 @@ import io.livekit.android.memory.CloseableManager
 import io.livekit.android.memory.SurfaceTextureHelperCloser
 import io.livekit.android.room.DefaultsManager
 import io.livekit.android.room.track.video.CameraCapturerUtils
+import io.livekit.android.room.track.video.CameraCapturerUtils.CameraDeviceInfo
 import io.livekit.android.room.track.video.CameraCapturerUtils.createCameraEnumerator
 import io.livekit.android.room.track.video.CameraCapturerUtils.findCamera
-import io.livekit.android.room.track.video.CameraCapturerUtils.getCameraPosition
 import io.livekit.android.room.track.video.CameraCapturerWithSize
 import io.livekit.android.room.track.video.CaptureDispatchObserver
 import io.livekit.android.room.track.video.ScaleCropVideoProcessor
@@ -179,26 +179,28 @@ constructor(
             return
         }
 
-        var targetDeviceId: String? = null
+        var targetDevice: CameraDeviceInfo? = null
         val enumerator = createCameraEnumerator(context)
         if (deviceId != null || position != null) {
-            targetDeviceId = enumerator.findCamera(deviceId, position, fallback = false)
+            targetDevice = enumerator.findCamera(deviceId, position, fallback = false)
         }
 
-        if (targetDeviceId == null) {
+        if (targetDevice == null) {
             val deviceNames = enumerator.deviceNames
             if (deviceNames.size < 2) {
                 LKLog.w { "No available cameras to switch to!" }
                 return
             }
             val currentIndex = deviceNames.indexOf(options.deviceId)
-            targetDeviceId = deviceNames[(currentIndex + 1) % deviceNames.size]
+            val targetDeviceId = deviceNames[(currentIndex + 1) % deviceNames.size]
+            targetDevice = enumerator.findCamera(targetDeviceId, fallback = false)
         }
 
+        val targetDeviceId = targetDevice?.deviceId
         fun updateCameraOptions() {
             val newOptions = options.copy(
                 deviceId = targetDeviceId,
-                position = enumerator.getCameraPosition(targetDeviceId),
+                position = targetDevice?.position,
             )
             options = newOptions
         }
@@ -243,7 +245,7 @@ constructor(
                 LKLog.w { "switching camera failed: $errorDescription" }
             }
         }
-        if (targetDeviceId == null) {
+        if (targetDevice == null) {
             LKLog.w { "No target camera found!" }
             return
         } else {