more accurate dimensions for video tracks

@@ -3,7 +3,11 @@ package io.livekit.android.room.track
 import android.Manifest
 import android.Manifest
 import android.content.Context
 import android.content.Context
 import android.content.pm.PackageManager
 import android.content.pm.PackageManager
+import android.hardware.camera2.CameraManager
 import androidx.core.content.ContextCompat
 import androidx.core.content.ContextCompat
+import io.livekit.android.room.track.video.Camera1CapturerWithSize
+import io.livekit.android.room.track.video.Camera2CapturerWithSize
+import io.livekit.android.room.track.video.VideoCapturerWithSize
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LKLog
 import org.webrtc.*
 import org.webrtc.*
 import java.util.*
 import java.util.*
@@ -28,14 +32,17 @@ open class LocalVideoTrack(
     override var rtcTrack: org.webrtc.VideoTrack = rtcTrack
     override var rtcTrack: org.webrtc.VideoTrack = rtcTrack
         internal set
         internal set
 
 
-    /**
-     * Note: these dimensions are only requested params, and may differ
-     * from the actual capture format used by the camera.
-     *
-     * TODO: capture actual dimensions used
-     */
     val dimensions: Dimensions
     val dimensions: Dimensions
-        get() = Dimensions(options.captureParams.width, options.captureParams.height)
+        get() {
+            (capturer as? VideoCapturerWithSize)?.let { capturerWithSize ->
+                val size = capturerWithSize.findCaptureFormat(
+                    options.captureParams.width,
+                    options.captureParams.height
+                )
+                return Dimensions(size.width, size.height)
+            }
+            return Dimensions(options.captureParams.width, options.captureParams.height)
+        }
 
 
     internal var transceiver: RtpTransceiver? = null
     internal var transceiver: RtpTransceiver? = null
     private val sender: RtpSender?
     private val sender: RtpSender?
@@ -127,9 +134,9 @@ open class LocalVideoTrack(
 
 
         private fun createVideoCapturer(context: Context, position: CameraPosition): VideoCapturer? {
         private fun createVideoCapturer(context: Context, position: CameraPosition): VideoCapturer? {
             val videoCapturer: VideoCapturer? = if (Camera2Enumerator.isSupported(context)) {
             val videoCapturer: VideoCapturer? = if (Camera2Enumerator.isSupported(context)) {
-                createCameraCapturer(Camera2Enumerator(context), position)
+                createCameraCapturer(context, Camera2Enumerator(context), position)
             } else {
             } else {
-                createCameraCapturer(Camera1Enumerator(true), position)
+                createCameraCapturer(context, Camera1Enumerator(true), position)
             }
             }
             if (videoCapturer == null) {
             if (videoCapturer == null) {
                 LKLog.d { "Failed to open camera" }
                 LKLog.d { "Failed to open camera" }
@@ -138,26 +145,47 @@ open class LocalVideoTrack(
             return videoCapturer
             return videoCapturer
         }
         }
 
 
-        private fun createCameraCapturer(enumerator: CameraEnumerator, position: CameraPosition): VideoCapturer? {
+        private fun createCameraCapturer(
+            context: Context,
+            enumerator: CameraEnumerator,
+            position: CameraPosition
+        ): VideoCapturer? {
             val deviceNames = enumerator.deviceNames
             val deviceNames = enumerator.deviceNames
-
+            var targetDeviceName: String? = null
+            var targetVideoCapturer: VideoCapturer? = null
             for (deviceName in deviceNames) {
             for (deviceName in deviceNames) {
                 if (enumerator.isFrontFacing(deviceName) && position == CameraPosition.FRONT) {
                 if (enumerator.isFrontFacing(deviceName) && position == CameraPosition.FRONT) {
                     LKLog.v { "Creating front facing camera capturer." }
                     LKLog.v { "Creating front facing camera capturer." }
                     val videoCapturer = enumerator.createCapturer(deviceName, null)
                     val videoCapturer = enumerator.createCapturer(deviceName, null)
                     if (videoCapturer != null) {
                     if (videoCapturer != null) {
-                        return videoCapturer
+                        targetDeviceName = deviceName
+                        targetVideoCapturer = videoCapturer
+                        break
                     }
                     }
                 } else if (enumerator.isBackFacing(deviceName) && position == CameraPosition.BACK) {
                 } else if (enumerator.isBackFacing(deviceName) && position == CameraPosition.BACK) {
                     LKLog.v { "Creating back facing camera capturer." }
                     LKLog.v { "Creating back facing camera capturer." }
                     val videoCapturer = enumerator.createCapturer(deviceName, null)
                     val videoCapturer = enumerator.createCapturer(deviceName, null)
                     if (videoCapturer != null) {
                     if (videoCapturer != null) {
-                        return videoCapturer
+                        targetDeviceName = deviceName
+                        targetVideoCapturer = videoCapturer
+                        break
                     }
                     }
                 }
                 }
             }
             }
+
+            if (targetVideoCapturer is Camera1Capturer) {
+                return Camera1CapturerWithSize(targetVideoCapturer, targetDeviceName)
+            }
+
+            if (targetVideoCapturer is Camera2Capturer) {
+                return Camera2CapturerWithSize(
+                    targetVideoCapturer,
+                    context.getSystemService(Context.CAMERA_SERVICE) as CameraManager,
+                    targetDeviceName
+                )
+            }
+
             return null
             return null
         }
         }
-
     }
     }
-}
+}

+package io.livekit.android.room.track.video
+
+import android.hardware.camera2.CameraManager
+import org.webrtc.*
+
+/**
+ * @suppress
+ */
+internal interface VideoCapturerWithSize : VideoCapturer {
+    fun findCaptureFormat(width: Int, height: Int): Size
+}
+
+/**
+ * @suppress
+ */
+internal class Camera1CapturerWithSize(
+    private val capturer: Camera1Capturer,
+    private val deviceName: String?
+) : VideoCapturer by capturer, VideoCapturerWithSize {
+    override fun findCaptureFormat(width: Int, height: Int): Size {
+        val cameraId = Camera1Helper.getCameraId(deviceName)
+        return Camera1Helper.findClosestCaptureFormat(cameraId, width, height)
+    }
+}
+
+/**
+ * @suppress
+ */
+internal class Camera2CapturerWithSize(
+    private val capturer: Camera2Capturer,
+    private val cameraManager: CameraManager,
+    private val deviceName: String?
+) : VideoCapturer by capturer, VideoCapturerWithSize {
+    override fun findCaptureFormat(width: Int, height: Int): Size {
+        return Camera2Helper.findClosestCaptureFormat(cameraManager, deviceName, width, height)
+    }
+}

+package org.webrtc
+
+/**
+ * A helper to access package-protected methods used in [Camera2Session]
+ * @suppress
+ */
+internal class Camera1Helper {
+    companion object {
+        fun getCameraId(deviceName: String?) = Camera1Enumerator.getCameraIndex(deviceName)
+
+        fun findClosestCaptureFormat(
+            cameraId: Int,
+            width: Int,
+            height: Int
+        ): Size {
+            return CameraEnumerationAndroid.getClosestSupportedSize(
+                Camera1Enumerator.getSupportedFormats(cameraId)
+                    .map { Size(it.width, it.height) },
+                width,
+                height
+            )
+        }
+    }
+}

+package org.webrtc
+
+import android.hardware.camera2.CameraManager
+
+/**
+ * A helper to access package-protected methods used in [Camera2Session]
+ * @suppress
+ */
+internal class Camera2Helper {
+    companion object {
+        fun findClosestCaptureFormat(
+            cameraManager: CameraManager,
+            cameraId: String?,
+            width: Int,
+            height: Int
+        ): Size {
+            val sizes = Camera2Enumerator.getSupportedFormats(cameraManager, cameraId)
+                ?.map { Size(it.width, it.height) }
+                ?: emptyList()
+            return CameraEnumerationAndroid.getClosestSupportedSize(sizes, width, height)
+        }
+    }
+}