@fishjam-cloud/react-native-client 0.4.1 → 0.5.0

package/android/build.gradle

@@ -2,7 +2,7 @@ apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
-def packageVersion = '0.4.1'
+def packageVersion = '0.5.0'
 
 group = 'io.fishjam.reactnative'
 version = "${packageVersion}"

package/android/src/main/java/io/fishjam/reactnative/EmitableEvents.kt

@@ -1,5 +1,9 @@
 package io.fishjam.reactnative
 
+import com.fishjamcloud.client.models.SimulcastConfig
+import com.twilio.audioswitch.AudioDevice
+import io.fishjam.reactnative.extensions.LocalCamera
+
 @Suppress("ktlint:standard:enum-entry-name-case")
 enum class PeerStatus {
   connecting,
@@ -8,21 +12,102 @@ enum class PeerStatus {
   idle
 }
 
-enum class EmitableEvents {
-  IsCameraOn,
-  IsMicrophoneOn,
-  IsScreenShareOn,
-  SimulcastConfigUpdate,
-  PeersUpdate,
-  AudioDeviceUpdate,
-  BandwidthEstimation,
-  ReconnectionRetriesLimitReached,
-  ReconnectionStarted,
-  Reconnected,
-  Warning,
-  PeerStatusChanged;
+class EmitableEvent private constructor(
+  private val event: EventName,
+  private val eventContent: Any? = null
+) {
+  enum class EventName {
+    IsMicrophoneOn,
+    IsScreenShareOn,
+    SimulcastConfigUpdate,
+    PeersUpdate,
+    AudioDeviceUpdate,
+    BandwidthEstimation,
+    ReconnectionRetriesLimitReached,
+    ReconnectionStarted,
+    Reconnected,
+    Warning,
+    PeerStatusChanged,
+    CurrentCameraChanged
+  }
+
+  val name: String
+    get() = event.name
+
+  val data: Map<String, Any?>
+    get() = mapOf(event.name to eventContent)
 
   companion object {
-    val allEvents = EmitableEvents.entries.map { it.name }.toTypedArray()
+    val reconnectionRetriesLimitReached = EmitableEvent(EventName.ReconnectionRetriesLimitReached)
+    val reconnectionStarted = EmitableEvent(EventName.ReconnectionStarted)
+    val reconnected = EmitableEvent(EventName.Reconnected)
+
+    fun isMicrophoneOn(enabled: Boolean) = EmitableEvent(EventName.IsMicrophoneOn, enabled)
+
+    fun isScreenShareOn(enabled: Boolean) = EmitableEvent(EventName.IsScreenShareOn, enabled)
+
+    fun bandwidthEstimation(estimation: Long) = EmitableEvent(EventName.BandwidthEstimation, estimation.toFloat())
+
+    fun warning(message: String) = EmitableEvent(EventName.Warning, message)
+
+    fun peerStatusChanged(peerStatus: PeerStatus) = EmitableEvent(EventName.PeerStatusChanged, peerStatus.name)
+
+    fun currentCameraChanged(
+      localCamera: LocalCamera?,
+      isCameraOn: Boolean
+    ) = EmitableEvent(
+      EventName.CurrentCameraChanged,
+      mapOf(
+        "currentCamera" to localCamera,
+        "isCameraOn" to isCameraOn
+      )
+    )
+
+    fun simulcastConfigUpdate(simulcastConfig: SimulcastConfig) =
+      EmitableEvent(
+        EventName.SimulcastConfigUpdate,
+        mapOf(
+          "enabled" to simulcastConfig.enabled,
+          "activeEncodings" to simulcastConfig.activeEncodings.map { it.rid }
+        )
+      )
+
+    fun peersUpdate(peersData: List<Map<String, Any?>>) = EmitableEvent(EventName.PeersUpdate, peersData)
+
+    fun audioDeviceUpdate(
+      audioDevices: List<AudioDevice>,
+      selectedDevice: AudioDevice?
+    ): EmitableEvent {
+      val audioDeviceAsMap = { audioDevice: AudioDevice ->
+        mapOf(
+          "name" to audioDevice.name,
+          "type" to AudioDeviceKind.fromAudioDevice(audioDevice)?.typeName
+        )
+      }
+
+      return EmitableEvent(
+        EventName.AudioDeviceUpdate,
+        mapOf(
+          "selectedDevice" to (
+            if (selectedDevice != null) {
+              audioDeviceAsMap(
+                selectedDevice
+              )
+            } else {
+              null
+            }
+          ),
+          "availableDevices" to
+            audioDevices.map { audioDevice ->
+              audioDeviceAsMap(
+                audioDevice
+              )
+            }
+        )
+      )
+    }
+
+    val allEvents: Array<String>
+      get() = EventName.entries.map { it.name }.toTypedArray()
   }
 }

package/android/src/main/java/io/fishjam/reactnative/RNFishjamClient.kt

@@ -7,6 +7,8 @@ import android.media.projection.MediaProjectionManager
 import androidx.appcompat.app.AppCompatActivity
 import com.fishjamcloud.client.FishjamClient
 import com.fishjamcloud.client.FishjamClientListener
+import com.fishjamcloud.client.media.CaptureDevice
+import com.fishjamcloud.client.media.CaptureDeviceChangedListener
 import com.fishjamcloud.client.media.LocalAudioTrack
 import com.fishjamcloud.client.media.LocalScreenShareTrack
 import com.fishjamcloud.client.media.LocalVideoTrack
@@ -27,6 +29,7 @@ import com.twilio.audioswitch.AudioDevice
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.CodedException
+import io.fishjam.reactnative.extensions.toLocalCamera
 import io.fishjam.reactnative.foregroundService.ForegroundServiceManager
 import io.fishjam.reactnative.managers.LocalCameraTracksChangedListenersManager
 import io.fishjam.reactnative.managers.LocalTracksSwitchListenersManager
@@ -40,7 +43,8 @@ import org.webrtc.Logging
 
 class RNFishjamClient(
   val sendEvent: (name: String, data: Map<String, Any?>) -> Unit
-) : FishjamClientListener {
+) : FishjamClientListener,
+  CaptureDeviceChangedListener {
   private val SCREENSHARE_REQUEST = 1
 
   var isMicrophoneOn = false
@@ -71,11 +75,12 @@ class RNFishjamClient(
   var peerStatus = PeerStatus.idle
     private set(value) {
       field = value
-      val event = EmitableEvents.PeerStatusChanged
-      emitEvent(event, mapOf(event.name to value))
+      emitEvent(EmitableEvent.peerStatusChanged(value))
     }
 
-  private var foregroundServiceManager: ForegroundServiceManager? = null
+  private val foregroundServiceManager by lazy {
+    ForegroundServiceManager(appContext ?: throw CodedException("appContext not found"))
+  }
 
   companion object {
     val trackUpdateListenersManager = TracksUpdateListenersManager()
@@ -254,7 +259,7 @@ class RNFishjamClient(
       com.fishjamcloud.client.ConnectConfig(
         url,
         peerToken,
-        localUserMetadata,
+        peerMetadata,
         ReconnectConfig(
           config.reconnectConfig.maxAttempts,
           config.reconnectConfig.initialDelayMs,
@@ -278,20 +283,22 @@ class RNFishjamClient(
     }
   }
 
-  suspend fun startCamera(config: CameraConfig) {
+  suspend fun startCamera(config: CameraConfig): Boolean {
     if (isCameraInitialized) {
-      emitWarning("Camera already started. You may only call startCamera once before leaveRoom is called.")
-      return
+      emitEvent(EmitableEvent.warning("Camera already started. You may only call startCamera once before leaveRoom is called."))
+      return true
     }
     if (!PermissionUtils.requestCameraPermission(appContext)) {
-      emitWarning("Camera permission not granted.")
-      return
+      emitEvent(EmitableEvent.warning("Camera permission not granted."))
+      return false
     }
 
     val cameraTrack = createCameraTrack(config)
+    cameraTrack.captureDeviceChangedListener = this
     setCameraTrackState(cameraTrack, config.cameraEnabled)
     emitEndpoints()
     isCameraInitialized = true
+    return true
   }
 
   private suspend fun createCameraTrack(config: CameraConfig): LocalVideoTrack {
@@ -310,8 +317,7 @@ class RNFishjamClient(
   ) {
     cameraTrack.setEnabled(isEnabled)
     isCameraOn = isEnabled
-    val event = EmitableEvents.IsCameraOn
-    emitEvent(event, mapOf(event.name to isEnabled))
+    emitEvent(EmitableEvent.currentCameraChanged(cameraTrack.getCaptureDevice()?.toLocalCamera(), isEnabled))
     localCameraTracksChangedListenersManager.notifyListeners()
   }
 
@@ -337,7 +343,7 @@ class RNFishjamClient(
 
   private suspend fun startMicrophone() {
     if (!PermissionUtils.requestMicrophonePermission(appContext)) {
-      emitWarning("Microphone permission not granted.")
+      emitEvent(EmitableEvent.warning("Microphone permission not granted."))
       return
     }
 
@@ -352,8 +358,7 @@ class RNFishjamClient(
   ) {
     microphoneTrack.setEnabled(isEnabled)
     isMicrophoneOn = isEnabled
-    val event = EmitableEvents.IsMicrophoneOn
-    emitEvent(event, mapOf(event.name to isEnabled))
+    emitEvent(EmitableEvent.isMicrophoneOn(isEnabled))
   }
 
   suspend fun toggleMicrophone(): Boolean {
@@ -362,6 +367,15 @@ class RNFishjamClient(
     } else {
       getLocalAudioTrack()?.let { setMicrophoneTrackState(it, !isMicrophoneOn) }
     }
+
+    updateLocalAudioTrackMetadata(
+      mapOf(
+        "active" to isMicrophoneOn,
+        "paused" to !isMicrophoneOn, // TODO: FCE-711,
+        "type" to "microphone"
+      )
+    )
+
     return isMicrophoneOn
   }
 
@@ -380,22 +394,13 @@ class RNFishjamClient(
     }
   }
 
-  fun configureForegroundService(config: ForegroundServiceNotificationConfig) {
-    if (foregroundServiceManager == null) {
-      foregroundServiceManager = ForegroundServiceManager(appContext!!, config)
-    }
-  }
-
-  suspend fun startForegroundService(config: ForegroundServicePermissionsConfig) {
-    if (foregroundServiceManager == null) {
-      throw CodedException("Foreground service not configured.")
-    }
-
-    foregroundServiceManager?.startForegroundService(config)
+  suspend fun startForegroundService(config: ForegroundServiceConfig) {
+    foregroundServiceManager.updateServiceWithConfig(config)
+    foregroundServiceManager.start()
   }
 
   fun stopForegroundService() {
-    foregroundServiceManager?.stopForegroundService()
+    foregroundServiceManager.stop()
   }
 
   suspend fun toggleScreenShare(screenShareOptions: ScreenShareOptions) {
@@ -408,6 +413,7 @@ class RNFishjamClient(
         screenShareOptions.maxBandwidthMap,
         screenShareOptions.maxBandwidthInt
       )
+
     if (!isScreenShareOn) {
       ensureConnected()
       startScreenShare()
@@ -421,7 +427,6 @@ class RNFishjamClient(
       mapOf(
         "id" to endpoint.id,
         "isLocal" to (endpoint.id == fishjamClient.getLocalEndpoint().id),
-        "type" to endpoint.type,
         "metadata" to endpoint.metadata,
         "tracks" to
           endpoint.tracks.values.mapNotNull { track ->
@@ -475,19 +480,12 @@ class RNFishjamClient(
   fun getCaptureDevices(): List<Map<String, Any>> {
     val devices = LocalVideoTrack.getCaptureDevices(appContext?.reactContext!!)
     return devices.map { device ->
-      mapOf<String, Any>(
-        "id" to device.deviceName,
-        "name" to device.deviceName,
-        "facingDirection" to
-          when (true) {
-            device.isFrontFacing -> "front"
-            device.isBackFacing -> "back"
-            else -> "unspecified"
-          }
-      )
+      device.toLocalCamera()
     }
   }
 
+  fun getCurrentCaptureDevice(): Map<String, Any>? = getLocalVideoTrack()?.getCaptureDevice()?.toLocalCamera()
+
   fun updatePeerMetadata(metadata: Metadata) {
     ensureConnected()
     fishjamClient.updatePeerMetadata(metadata)
@@ -508,7 +506,7 @@ class RNFishjamClient(
     }
   }
 
-  fun updateLocalAudioTrackMetadata(metadata: Metadata) {
+  private fun updateLocalAudioTrackMetadata(metadata: Metadata) {
     ensureAudioTrack()
     getLocalAudioTrack()?.let {
       updateTrackMetadata(it.id(), metadata)
@@ -606,13 +604,15 @@ class RNFishjamClient(
     fishjamClient.setTargetTrackEncoding(trackId, encoding.toTrackEncoding())
   }
 
-  fun toggleVideoTrackEncoding(encoding: String): Map<String, Any> {
+  fun toggleVideoTrackEncoding(encoding: String): Map<String, Any?> {
     ensureVideoTrack()
     val trackId = getLocalVideoTrack()?.id() ?: return emptyMap()
     videoSimulcastConfig = toggleTrackEncoding(encoding, trackId, videoSimulcastConfig)
-    val eventName = EmitableEvents.SimulcastConfigUpdate
-    emitEvent(eventName, getSimulcastConfigAsRNMap(videoSimulcastConfig))
-    return getSimulcastConfigAsRNMap(videoSimulcastConfig)
+
+    val event = EmitableEvent.simulcastConfigUpdate(videoSimulcastConfig)
+    emitEvent(event)
+
+    return event.data
   }
 
   fun setVideoTrackEncodingBandwidth(
@@ -712,6 +712,10 @@ class RNFishjamClient(
     if (mediaProjectionIntent == null) {
       throw MissingScreenSharePermission()
     }
+
+    foregroundServiceManager.updateService { screenSharingEnabled = true }
+    foregroundServiceManager.start()
+
     fishjamClient.createScreenShareTrack(
       mediaProjectionIntent!!,
       videoParameters,
@@ -743,13 +747,14 @@ class RNFishjamClient(
 
   private fun setScreenShareTrackState(isEnabled: Boolean) {
     isScreenShareOn = isEnabled
-    val event = EmitableEvents.IsScreenShareOn
-    emitEvent(event, mapOf(event.name to isEnabled))
+    emitEvent(EmitableEvent.isScreenShareOn(isEnabled))
   }
 
   private fun stopScreenShare() {
     ensureScreenShareTrack()
     coroutineScope.launch {
+      foregroundServiceManager.updateService { screenSharingEnabled = false }
+      foregroundServiceManager.start()
       val screenShareTrack =
         fishjamClient.getLocalEndpoint().tracks.values.first { track ->
           track is LocalScreenShareTrack
@@ -762,58 +767,21 @@ class RNFishjamClient(
     }
   }
 
-  private fun emitEvent(
-    event: EmitableEvents,
-    data: Map<String, Any?> = mapOf()
-  ) {
+  private fun emitEvent(event: EmitableEvent) {
     CoroutineScope(Dispatchers.Main).launch {
-      sendEvent(event.name, data)
+      sendEvent(event.name, event.data)
     }
   }
 
-  fun emitWarning(warning: String) {
-    emitEvent(EmitableEvents.Warning, mapOf("message" to warning))
-  }
-
   private fun emitEndpoints() {
-    val event = EmitableEvents.PeersUpdate
-    emitEvent(event, mapOf(event.name to getPeers()))
+    emitEvent(EmitableEvent.peersUpdate(getPeers()))
   }
 
-  private fun audioDeviceAsRNMap(audioDevice: AudioDevice): Map<String, String?> =
-    mapOf(
-      "name" to audioDevice.name,
-      "type" to AudioDeviceKind.fromAudioDevice(audioDevice)?.typeName
-    )
-
   private fun emitAudioDeviceEvent(
     audioDevices: List<AudioDevice>,
     selectedDevice: AudioDevice?
   ) {
-    val event = EmitableEvents.AudioDeviceUpdate
-    emitEvent(
-      event,
-      mapOf(
-        event.name to
-          mapOf(
-            "selectedDevice" to (
-              if (selectedDevice != null) {
-                audioDeviceAsRNMap(
-                  selectedDevice
-                )
-              } else {
-                null
-              }
-            ),
-            "availableDevices" to
-              audioDevices.map { audioDevice ->
-                audioDeviceAsRNMap(
-                  audioDevice
-                )
-              }
-          )
-      )
-    )
+    emitEvent(EmitableEvent.audioDeviceUpdate(audioDevices, selectedDevice))
   }
 
   private fun getSimulcastConfigAsRNMap(simulcastConfig: SimulcastConfig): Map<String, Any> =
@@ -885,8 +853,7 @@ class RNFishjamClient(
   override fun onPeerUpdated(peer: Peer) {}
 
   override fun onBandwidthEstimationChanged(estimation: Long) {
-    val event = EmitableEvents.BandwidthEstimation
-    emitEvent(event, mapOf(event.name to estimation.toFloat()))
+    emitEvent(EmitableEvent.bandwidthEstimation(estimation))
   }
 
   override fun onDisconnected() {
@@ -912,14 +879,18 @@ class RNFishjamClient(
   }
 
   override fun onReconnected() {
-    emitEvent(EmitableEvents.Reconnected)
+    emitEvent(EmitableEvent.reconnected)
   }
 
   override fun onReconnectionStarted() {
-    emitEvent(EmitableEvents.ReconnectionStarted)
+    emitEvent(EmitableEvent.reconnectionStarted)
   }
 
   override fun onReconnectionRetriesLimitReached() {
-    emitEvent(EmitableEvents.ReconnectionRetriesLimitReached)
+    emitEvent(EmitableEvent.reconnectionRetriesLimitReached)
+  }
+
+  override fun onCaptureDeviceChanged(captureDevice: CaptureDevice?) {
+    emitEvent(EmitableEvent.currentCameraChanged(captureDevice?.toLocalCamera(), isCameraOn))
   }
 }

package/android/src/main/java/io/fishjam/reactnative/RNFishjamClientModule.kt

@@ -81,7 +81,7 @@ class ConnectConfig : Record {
   val reconnectConfig: ReconnectConfig = ReconnectConfig()
 }
 
-class ForegroundServiceNotificationConfig : Record {
+class ForegroundServiceConfig : Record {
   @Field
   val channelId: String? = null
 
@@ -93,17 +93,12 @@ class ForegroundServiceNotificationConfig : Record {
 
   @Field
   val notificationTitle: String? = null
-}
-
-class ForegroundServicePermissionsConfig : Record {
-  @Field
-  val enableCamera: Boolean = false
 
   @Field
-  val enableMicrophone: Boolean = false
+  val enableCamera: Boolean? = null
 
   @Field
-  val enableScreenSharing: Boolean = false
+  val enableMicrophone: Boolean? = null
 }
 
 class RNFishjamClientModule : Module() {
@@ -118,7 +113,7 @@ class RNFishjamClientModule : Module() {
 
       Name("RNFishjamClient")
 
-      Events(EmitableEvents.allEvents)
+      Events(EmitableEvent.allEvents)
 
       OnCreate {
         rnFishjamClient.onModuleCreate(appContext)
@@ -148,6 +143,10 @@ class RNFishjamClientModule : Module() {
         return@Property rnFishjamClient.getCaptureDevices()
       }
 
+      Property("currentCamera") {
+        return@Property rnFishjamClient.getCurrentCaptureDevice()
+      }
+
       Property("isScreenShareOn") {
         return@Property rnFishjamClient.isScreenShareOn
       }
@@ -171,8 +170,8 @@ class RNFishjamClientModule : Module() {
       }
 
       AsyncFunction("startCamera") Coroutine { config: CameraConfig ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.startCamera(config)
+        return@Coroutine withContext(Dispatchers.Main) {
+          return@withContext rnFishjamClient.startCamera(config)
         }
       }
 
@@ -234,12 +233,6 @@ class RNFishjamClientModule : Module() {
         }
       }
 
-      AsyncFunction("updateAudioTrackMetadata") Coroutine { metadata: Map<String, Any> ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.updateLocalAudioTrackMetadata(metadata)
-        }
-      }
-
       AsyncFunction("updateScreenShareTrackMetadata") Coroutine { metadata: Map<String, Any> ->
         withContext(Dispatchers.Main) {
           rnFishjamClient.updateLocalScreenShareTrackMetadata(metadata)
@@ -301,18 +294,14 @@ class RNFishjamClientModule : Module() {
       }
 
       AsyncFunction("changeWebRTCLoggingSeverity") Coroutine { severity: String ->
-        CoroutineScope(Dispatchers.Main).launch {
+        withContext(Dispatchers.Main) {
           rnFishjamClient.changeWebRTCLoggingSeverity(severity)
         }
       }
 
       AsyncFunction("getStatistics") { rnFishjamClient.getStatistics() }
 
-      Function("configureForegroundService") { config: ForegroundServiceNotificationConfig ->
-        return@Function rnFishjamClient.configureForegroundService(config)
-      }
-
-      AsyncFunction("startForegroundService") Coroutine { config: ForegroundServicePermissionsConfig ->
+      AsyncFunction("startForegroundService") Coroutine { config: ForegroundServiceConfig ->
         rnFishjamClient.startForegroundService(config)
       }
 

package/android/src/main/java/io/fishjam/reactnative/VideoRendererViewModule.kt

@@ -15,13 +15,17 @@ class VideoRendererViewModule : Module() {
           RNFishjamClient.localTracksSwitchListenerManager.remove(view)
         }
 
-        Prop("trackId") { view: VideoRendererView, trackId: String ->
+        Prop("trackId") { view, trackId: String ->
           view.init(trackId)
         }
 
-        Prop("videoLayout") { view: VideoRendererView, videoLayout: String ->
+        Prop("videoLayout") { view, videoLayout: String ->
           view.setVideoLayout(videoLayout)
         }
+
+        Prop("skipRenderOutsideVisibleArea") { view, skipRenderOutsideVisibleArea: Boolean ->
+          view.checkVisibilityDelayMillis = if (skipRenderOutsideVisibleArea) 1000 else null
+        }
       }
     }
 }

package/android/src/main/java/io/fishjam/reactnative/VideoView.kt

@@ -2,16 +2,18 @@ package io.fishjam.reactnative
 
 import android.animation.ValueAnimator
 import android.content.Context
+import android.content.res.Resources
 import android.graphics.Color
+import android.graphics.Rect
 import android.graphics.drawable.ColorDrawable
+import android.os.Handler
+import android.os.Looper
 import android.view.animation.LinearInterpolator
 import com.fishjamcloud.client.media.LocalVideoTrack
 import com.fishjamcloud.client.media.VideoTrack
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.views.ExpoView
 import io.fishjam.reactnative.managers.LocalTrackSwitchListener
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import org.webrtc.RendererCommon
 
@@ -35,7 +37,41 @@ abstract class VideoView(
       }
     }
 
-  val coroutineScope: CoroutineScope = CoroutineScope(Dispatchers.Main)
+  private val checkVisibilityHandler: Handler = Handler(Looper.getMainLooper())
+
+  // If set to `null` the view will always be rendered
+  var checkVisibilityDelayMillis: Long? = null
+    set(value) {
+      field = value
+      if (value == null) {
+        getVideoTrack()?.shouldReceive(true)
+      } else {
+        checkVisibilityHandler.post(checkVisibility)
+      }
+    }
+
+  private val checkVisibility =
+    object : Runnable {
+      override fun run() {
+        checkVisibilityDelayMillis?.let {
+          getVideoTrack()?.shouldReceive(isVisibleOnScreen)
+          checkVisibilityHandler.postDelayed(this, it)
+        }
+      }
+    }
+
+  private val isVisibleOnScreen: Boolean
+    get() {
+      if (!isShown) {
+        return false
+      }
+
+      val globalVisibleRect = Rect()
+      getGlobalVisibleRect(globalVisibleRect)
+      val displayMetrics = Resources.getSystem().displayMetrics
+      val screen = Rect(0, 0, displayMetrics.widthPixels, displayMetrics.heightPixels)
+      return screen.intersect(globalVisibleRect)
+    }
 
   init {
     RNFishjamClient.localTracksSwitchListenerManager.add(this)
@@ -53,6 +89,7 @@ abstract class VideoView(
   }
 
   open fun dispose() {
+    checkVisibilityHandler.removeCallbacksAndMessages(null)
     videoView.release()
   }
 
@@ -74,5 +111,6 @@ abstract class VideoView(
 
   fun setupTrack() {
     videoView.setMirror((getVideoTrack() as? LocalVideoTrack)?.isFrontCamera() ?: false)
+    checkVisibilityHandler.post(checkVisibility)
   }
 }

package/android/src/main/java/io/fishjam/reactnative/extensions/CaptureDevice.kt

@@ -0,0 +1,17 @@
+package io.fishjam.reactnative.extensions
+
+import com.fishjamcloud.client.media.CaptureDevice
+
+typealias LocalCamera = Map<String, Any>
+
+fun CaptureDevice.toLocalCamera(): LocalCamera =
+  mapOf<String, Any>(
+    "id" to deviceName,
+    "name" to deviceName,
+    "facingDirection" to
+      when (true) {
+        isFrontFacing -> "front"
+        isBackFacing -> "back"
+        else -> "unspecified"
+      }
+  )