@fishjam-cloud/react-native-client 0.2.3 → 0.3.0

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

@@ -1,15 +1,28 @@
 package io.fishjam.reactnative
 
-object EmitableEvents {
-  const val IsCameraOn = "IsCameraOn"
-  const val IsMicrophoneOn = "IsMicrophoneOn"
-  const val IsScreencastOn = "IsScreencastOn"
-  const val SimulcastConfigUpdate = "SimulcastConfigUpdate"
-  const val PeersUpdate = "PeersUpdate"
-  const val AudioDeviceUpdate = "AudioDeviceUpdate"
-  const val BandwidthEstimation = "BandwidthEstimation"
-  const val ReconnectionRetriesLimitReached = "ReconnectionRetriesLimitReached"
-  const val ReconnectionStarted = "ReconnectionStarted"
-  const val Reconnected = "Reconnected"
-  const val Warning = "Warning"
+@Suppress("ktlint:standard:enum-entry-name-case")
+enum class PeerStatus {
+  connecting,
+  connected,
+  error,
+  idle
+}
+
+enum class EmitableEvents {
+  IsCameraOn,
+  IsMicrophoneOn,
+  IsScreenShareOn,
+  SimulcastConfigUpdate,
+  PeersUpdate,
+  AudioDeviceUpdate,
+  BandwidthEstimation,
+  ReconnectionRetriesLimitReached,
+  ReconnectionStarted,
+  Reconnected,
+  Warning,
+  PeerStatusChanged;
+
+  companion object {
+    val allEvents = EmitableEvents.entries.map { it.name }.toTypedArray()
+  }
 }

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

@@ -11,7 +11,8 @@ class ConnectionError(
   reason: AuthError
 ) : CodedException(message = "Connection error: ${reason.error}")
 
-class MissingScreencastPermission : CodedException(message = "No permission to start screencast, call handleScreencastPermission first.")
+class MissingScreenSharePermission :
+  CodedException(message = "No permission to start screen share, call handleScreenSharePermission first.")
 
 class ClientNotConnectedError : CodedException(message = "Client not connected to server yet. Make sure to call connect() first!")
 
@@ -19,7 +20,7 @@ class NoLocalVideoTrackError : CodedException(message = "No local video track. M
 
 class NoLocalAudioTrackError : CodedException(message = "No local audio track. Make sure to call connect() first!")
 
-class NoScreencastTrackError : CodedException(message = "No local screencast track. Make sure to toggle screencast on first!")
+class NoScreenShareTrackError : CodedException(message = "No local screen share track. Make sure to toggle screen share on first!")
 
 class SocketClosedError(
   code: Int,

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

@@ -8,7 +8,7 @@ import androidx.appcompat.app.AppCompatActivity
 import com.fishjamcloud.client.FishjamClient
 import com.fishjamcloud.client.FishjamClientListener
 import com.fishjamcloud.client.media.LocalAudioTrack
-import com.fishjamcloud.client.media.LocalScreencastTrack
+import com.fishjamcloud.client.media.LocalScreenShareTrack
 import com.fishjamcloud.client.media.LocalVideoTrack
 import com.fishjamcloud.client.media.RemoteAudioTrack
 import com.fishjamcloud.client.media.RemoteVideoTrack
@@ -36,26 +36,26 @@ import org.webrtc.Logging
 class RNFishjamClient(
   val sendEvent: (name: String, data: Map<String, Any?>) -> Unit
 ) : FishjamClientListener {
-  private val SCREENCAST_REQUEST = 1
+  private val SCREENSHARE_REQUEST = 1
 
   var isMicrophoneOn = false
   var isCameraOn = false
-  var isScreencastOn = false
+  var isScreenShareOn = false
   var isConnected = false
 
   private var isCameraInitialized = false
 
   private var connectPromise: Promise? = null
-  private var screencastPermissionPromise: Promise? = null
+  private var screenSharePermissionPromise: Promise? = null
 
   var videoSimulcastConfig: SimulcastConfig = SimulcastConfig()
   private var localUserMetadata: Metadata = mutableMapOf()
 
-  var screencastQuality: String? = null
-  var screencastSimulcastConfig: SimulcastConfig = SimulcastConfig()
-  var screencastMaxBandwidth: TrackBandwidthLimit = TrackBandwidthLimit.BandwidthLimit(0)
+  var screenShareQuality: String? = null
+  var screenShareSimulcastConfig: SimulcastConfig = SimulcastConfig()
+  var screenShareMaxBandwidth: TrackBandwidthLimit = TrackBandwidthLimit.BandwidthLimit(0)
 
-  var screencastMetadata: Map<String, Any> = mutableMapOf()
+  var screenShareMetadata: Map<String, Any> = mutableMapOf()
 
   private var mediaProjectionIntent: Intent? = null
 
@@ -63,6 +63,13 @@ class RNFishjamClient(
 
   var appContext: AppContext? = null
 
+  var peerStatus = PeerStatus.idle
+    private set(value) {
+      field = value
+      val event = EmitableEvents.PeerStatusChanged
+      emitEvent(event, mapOf(event.name to value))
+    }
+
   interface OnTrackUpdateListener {
     fun onTracksUpdate()
   }
@@ -73,9 +80,14 @@ class RNFishjamClient(
     suspend fun onLocalTrackSwitched()
   }
 
+  interface OnLocalCameraTrackChangedListener {
+    fun onLocalCameraTrackChanged()
+  }
+
   companion object {
     var onTracksUpdateListeners: MutableList<OnTrackUpdateListener> = mutableListOf()
     val onLocalTrackSwitchListener: MutableList<OnLocalTrackSwitchListener> = mutableListOf()
+    var localCameraTrackListeners: MutableList<OnLocalCameraTrackChangedListener> = mutableListOf()
     lateinit var fishjamClient: FishjamClient
 
     fun getAllPeers(): List<Peer> {
@@ -105,16 +117,16 @@ class RNFishjamClient(
     data: Intent?
   ) {
     coroutineScope.launch(Dispatchers.Main) {
-      if (requestCode != SCREENCAST_REQUEST) return@launch
+      if (requestCode != SCREENSHARE_REQUEST) return@launch
       if (resultCode != Activity.RESULT_OK) {
-        screencastPermissionPromise?.resolve("denied")
-        screencastPermissionPromise = null
+        screenSharePermissionPromise?.resolve("denied")
+        screenSharePermissionPromise = null
         return@launch
       }
 
       mediaProjectionIntent = data
-      screencastPermissionPromise?.resolve("granted")
-      screencastPermissionPromise = null
+      screenSharePermissionPromise?.resolve("granted")
+      screenSharePermissionPromise = null
     }
   }
 
@@ -169,7 +181,7 @@ class RNFishjamClient(
       }
     videoParameters =
       videoParameters.copy(
-        dimensions = if (createOptions.flipVideo) videoParameters.dimensions.flip() else videoParameters.dimensions,
+        dimensions = if (createOptions.flipDimensions) videoParameters.dimensions.flip() else videoParameters.dimensions,
         simulcastConfig = getSimulcastConfigFromOptions(createOptions.simulcastConfig),
         maxBitrate = videoMaxBandwidth
       )
@@ -192,12 +204,12 @@ class RNFishjamClient(
       .filterIsInstance<LocalAudioTrack>()
       .firstOrNull()
 
-  private fun getLocalScreencastTrack(): LocalScreencastTrack? =
+  private fun getLocalScreenShareTrack(): LocalScreenShareTrack? =
     fishjamClient
       .getLocalEndpoint()
       .tracks
       .values
-      .filterIsInstance<LocalScreencastTrack>()
+      .filterIsInstance<LocalScreenShareTrack>()
       .firstOrNull()
 
   private fun ensureConnected() {
@@ -218,9 +230,9 @@ class RNFishjamClient(
     }
   }
 
-  private fun ensureScreencastTrack() {
-    if (getLocalScreencastTrack() == null) {
-      throw NoScreencastTrackError()
+  private fun ensureScreenShareTrack() {
+    if (getLocalScreenShareTrack() == null) {
+      throw NoScreenShareTrackError()
     }
   }
 
@@ -228,23 +240,25 @@ class RNFishjamClient(
     CoroutineScope(Dispatchers.Main).launch {
       connectPromise?.reject(ConnectionError(reason))
       connectPromise = null
+      peerStatus = PeerStatus.error
     }
   }
 
   fun joinRoom(
     url: String,
-    participantToken: String,
-    participantMetadata: Map<String, Any>,
+    peerToken: String,
+    peerMetadata: Map<String, Any>,
     config: ConnectConfig,
     promise: Promise
   ) {
+    peerStatus = PeerStatus.connecting
     connectPromise = promise
-    localUserMetadata = participantMetadata
+    localUserMetadata = peerMetadata
     fishjamClient.connect(
       com.fishjamcloud.client.ConnectConfig(
         url,
-        participantToken,
-        participantMetadata,
+        peerToken,
+        peerMetadata,
         ReconnectConfig(
           config.reconnectConfig.maxAttempts,
           config.reconnectConfig.initialDelayMs,
@@ -255,15 +269,17 @@ class RNFishjamClient(
   }
 
   fun leaveRoom() {
-    if (isScreencastOn) {
-      stopScreencast()
+    if (isScreenShareOn) {
+      stopScreenShare()
     }
     isMicrophoneOn = false
     isCameraOn = false
-    isScreencastOn = false
+    isScreenShareOn = false
     isConnected = false
     isCameraInitialized = false
-    fishjamClient.leave()
+    fishjamClient.leave {
+      emitEndpoints()
+    }
   }
 
   suspend fun startCamera(config: CameraConfig) {
@@ -293,9 +309,9 @@ class RNFishjamClient(
   ) {
     cameraTrack.setEnabled(isEnabled)
     isCameraOn = isEnabled
-    val eventName = EmitableEvents.IsCameraOn
-    val isCameraOnMap = mapOf(eventName to isEnabled)
-    emitEvent(eventName, isCameraOnMap)
+    val event = EmitableEvents.IsCameraOn
+    emitEvent(event, mapOf(event.name to isEnabled))
+    localCameraTrackListeners.forEach { it.onLocalCameraTrackChanged() }
   }
 
   fun toggleCamera(): Boolean {
@@ -332,9 +348,8 @@ class RNFishjamClient(
   ) {
     microphoneTrack.setEnabled(isEnabled)
     isMicrophoneOn = isEnabled
-    val eventName = EmitableEvents.IsMicrophoneOn
-    val isMicrophoneOnMap = mapOf(eventName to isEnabled)
-    emitEvent(eventName, isMicrophoneOnMap)
+    val event = EmitableEvents.IsMicrophoneOn
+    emitEvent(event, mapOf(event.name to isEnabled))
   }
 
   suspend fun toggleMicrophone(): Boolean {
@@ -346,9 +361,9 @@ class RNFishjamClient(
     return isMicrophoneOn
   }
 
-  fun handleScreencastPermission(promise: Promise) {
-    screencastPermissionPromise = promise
-    if (!isScreencastOn) {
+  fun handleScreenSharePermission(promise: Promise) {
+    screenSharePermissionPromise = promise
+    if (!isScreenShareOn) {
       ensureConnected()
       val currentActivity = appContext?.currentActivity ?: throw ActivityNotFoundException()
 
@@ -357,25 +372,25 @@ class RNFishjamClient(
           AppCompatActivity.MEDIA_PROJECTION_SERVICE
         ) as MediaProjectionManager
       val intent = mediaProjectionManager.createScreenCaptureIntent()
-      currentActivity.startActivityForResult(intent, SCREENCAST_REQUEST)
+      currentActivity.startActivityForResult(intent, SCREENSHARE_REQUEST)
     }
   }
 
-  suspend fun toggleScreencast(screencastOptions: ScreencastOptions) {
-    this.screencastMetadata = screencastOptions.screencastMetadata
-    this.screencastQuality = screencastOptions.quality
-    this.screencastSimulcastConfig =
-      getSimulcastConfigFromOptions(screencastOptions.simulcastConfig)
-    this.screencastMaxBandwidth =
+  suspend fun toggleScreenShare(screenShareOptions: ScreenShareOptions) {
+    this.screenShareMetadata = screenShareOptions.screenShareMetadata
+    this.screenShareQuality = screenShareOptions.quality
+    this.screenShareSimulcastConfig =
+      getSimulcastConfigFromOptions(screenShareOptions.simulcastConfig)
+    this.screenShareMaxBandwidth =
       getMaxBandwidthFromOptions(
-        screencastOptions.maxBandwidthMap,
-        screencastOptions.maxBandwidthInt
+        screenShareOptions.maxBandwidthMap,
+        screenShareOptions.maxBandwidthInt
       )
-    if (!isScreencastOn) {
+    if (!isScreenShareOn) {
       ensureConnected()
-      startScreencast()
+      startScreenShare()
     } else {
-      stopScreencast()
+      stopScreenShare()
     }
   }
 
@@ -413,7 +428,7 @@ class RNFishjamClient(
                   "metadata" to track.metadata
                 )
 
-              is LocalScreencastTrack ->
+              is LocalScreenShareTrack ->
                 mapOf(
                   "id" to track.id(),
                   "type" to "Video",
@@ -478,9 +493,9 @@ class RNFishjamClient(
     }
   }
 
-  fun updateLocalScreencastTrackMetadata(metadata: Metadata) {
-    ensureScreencastTrack()
-    getLocalScreencastTrack()?.let {
+  fun updateLocalScreenShareTrackMetadata(metadata: Metadata) {
+    ensureScreenShareTrack()
+    getLocalScreenShareTrack()?.let {
       updateTrackMetadata(it.id(), metadata)
     }
   }
@@ -531,27 +546,27 @@ class RNFishjamClient(
     )
   }
 
-  fun toggleScreencastTrackEncoding(encoding: String): Map<String, Any> {
-    ensureScreencastTrack()
-    getLocalScreencastTrack()?.let {
-      screencastSimulcastConfig = toggleTrackEncoding(encoding, it.id(), screencastSimulcastConfig)
+  fun toggleScreenShareTrackEncoding(encoding: String): Map<String, Any> {
+    ensureScreenShareTrack()
+    getLocalScreenShareTrack()?.let {
+      screenShareSimulcastConfig = toggleTrackEncoding(encoding, it.id(), screenShareSimulcastConfig)
     }
-    return getSimulcastConfigAsRNMap(screencastSimulcastConfig)
+    return getSimulcastConfigAsRNMap(screenShareSimulcastConfig)
   }
 
-  fun setScreencastTrackBandwidth(bandwidth: Int) {
-    ensureScreencastTrack()
-    getLocalScreencastTrack()?.let {
+  fun setScreenShareTrackBandwidth(bandwidth: Int) {
+    ensureScreenShareTrack()
+    getLocalScreenShareTrack()?.let {
       fishjamClient.setTrackBandwidth(it.id(), TrackBandwidthLimit.BandwidthLimit(bandwidth))
     }
   }
 
-  fun setScreencastTrackEncodingBandwidth(
+  fun setScreenShareTrackEncodingBandwidth(
     encoding: String,
     bandwidth: Int
   ) {
-    ensureScreencastTrack()
-    getLocalScreencastTrack()?.let {
+    ensureScreenShareTrack()
+    getLocalScreenShareTrack()?.let {
       fishjamClient.setEncodingBandwidth(
         it.id(),
         encoding,
@@ -669,25 +684,25 @@ class RNFishjamClient(
     return newMap
   }
 
-  private suspend fun startScreencast() {
-    val videoParameters = getScreencastVideoParameters()
+  private suspend fun startScreenShare() {
+    val videoParameters = getScreenShareVideoParameters()
     if (mediaProjectionIntent == null) {
-      throw MissingScreencastPermission()
+      throw MissingScreenSharePermission()
     }
-    fishjamClient.createScreencastTrack(
+    fishjamClient.createScreenShareTrack(
       mediaProjectionIntent!!,
       videoParameters,
-      screencastMetadata
+      screenShareMetadata
     )
     mediaProjectionIntent = null
 
-    setScreencastTrackState(true)
+    setScreenShareTrackState(true)
     emitEndpoints()
   }
 
-  private fun getScreencastVideoParameters(): VideoParameters {
+  private fun getScreenShareVideoParameters(): VideoParameters {
     val videoParameters =
-      when (screencastQuality) {
+      when (screenShareQuality) {
         "VGA" -> VideoParameters.presetScreenShareVGA
         "HD5" -> VideoParameters.presetScreenShareHD5
         "HD15" -> VideoParameters.presetScreenShareHD15
@@ -698,48 +713,46 @@ class RNFishjamClient(
     val dimensions = videoParameters.dimensions.flip()
     return videoParameters.copy(
       dimensions = dimensions,
-      simulcastConfig = screencastSimulcastConfig,
-      maxBitrate = screencastMaxBandwidth
+      simulcastConfig = screenShareSimulcastConfig,
+      maxBitrate = screenShareMaxBandwidth
     )
   }
 
-  private fun setScreencastTrackState(isEnabled: Boolean) {
-    isScreencastOn = isEnabled
-    val eventName = EmitableEvents.IsScreencastOn
-    emitEvent(eventName, mapOf(eventName to isEnabled))
+  private fun setScreenShareTrackState(isEnabled: Boolean) {
+    isScreenShareOn = isEnabled
+    val event = EmitableEvents.IsScreenShareOn
+    emitEvent(event, mapOf(event.name to isEnabled))
   }
 
-  private fun stopScreencast() {
-    ensureScreencastTrack()
+  private fun stopScreenShare() {
+    ensureScreenShareTrack()
     coroutineScope.launch {
-      val screencastTrack =
+      val screenShareTrack =
         fishjamClient.getLocalEndpoint().tracks.values.first { track ->
-          track is LocalScreencastTrack
-        } as? LocalScreencastTrack
-      if (screencastTrack != null) {
-        fishjamClient.removeTrack(screencastTrack.id())
+          track is LocalScreenShareTrack
+        } as? LocalScreenShareTrack
+      if (screenShareTrack != null) {
+        fishjamClient.removeTrack(screenShareTrack.id())
       }
-      setScreencastTrackState(false)
+      setScreenShareTrackState(false)
       emitEndpoints()
     }
   }
 
   private fun emitEvent(
-    eventName: String,
-    data: Map<String, Any?>
+    event: EmitableEvents,
+    data: Map<String, Any?> = mapOf()
   ) {
-    sendEvent(eventName, data)
+    sendEvent(event.name, data)
   }
 
   private fun emitWarning(warning: String) {
-    val eventName = EmitableEvents.Warning
-    emitEvent(eventName, mapOf("message" to warning))
+    emitEvent(EmitableEvents.Warning, mapOf("message" to warning))
   }
 
   private fun emitEndpoints() {
-    val eventName = EmitableEvents.PeersUpdate
-    val map = mapOf(eventName to getPeers())
-    emitEvent(eventName, map)
+    val event = EmitableEvents.PeersUpdate
+    emitEvent(event, mapOf(event.name to getPeers()))
   }
 
   private fun audioDeviceAsRNMap(audioDevice: AudioDevice): Map<String, String?> =
@@ -752,10 +765,11 @@ class RNFishjamClient(
     audioDevices: List<AudioDevice>,
     selectedDevice: AudioDevice?
   ) {
-    val eventName = EmitableEvents.AudioDeviceUpdate
-    val map =
+    val event = EmitableEvents.AudioDeviceUpdate
+    emitEvent(
+      event,
       mapOf(
-        eventName to
+        event.name to
           mapOf(
             "selectedDevice" to (
               if (selectedDevice != null) {
@@ -774,8 +788,7 @@ class RNFishjamClient(
               }
           )
       )
-
-    emitEvent(eventName, map)
+    )
   }
 
   private fun getSimulcastConfigAsRNMap(simulcastConfig: SimulcastConfig): Map<String, Any> =
@@ -796,6 +809,7 @@ class RNFishjamClient(
       connectPromise?.resolve(null)
       connectPromise = null
       emitEndpoints()
+      peerStatus = PeerStatus.connected
     }
   }
 
@@ -846,11 +860,13 @@ class RNFishjamClient(
   override fun onPeerUpdated(peer: Peer) {}
 
   override fun onBandwidthEstimationChanged(estimation: Long) {
-    val eventName = EmitableEvents.BandwidthEstimation
-    emitEvent(eventName, mapOf(eventName to estimation.toFloat()))
+    val event = EmitableEvents.BandwidthEstimation
+    emitEvent(event, mapOf(event.name to estimation.toFloat()))
   }
 
-  override fun onDisconnected() {}
+  override fun onDisconnected() {
+    peerStatus = PeerStatus.idle
+  }
 
   override fun onSocketClose(
     code: Int,
@@ -859,6 +875,7 @@ class RNFishjamClient(
     CoroutineScope(Dispatchers.Main).launch {
       connectPromise?.reject(SocketClosedError(code, reason))
       connectPromise = null
+      peerStatus = PeerStatus.error
     }
   }
 
@@ -870,14 +887,14 @@ class RNFishjamClient(
   }
 
   override fun onReconnected() {
-    emitEvent(EmitableEvents.Reconnected, emptyMap())
+    emitEvent(EmitableEvents.Reconnected)
   }
 
   override fun onReconnectionStarted() {
-    emitEvent(EmitableEvents.ReconnectionStarted, emptyMap())
+    emitEvent(EmitableEvents.ReconnectionStarted)
   }
 
   override fun onReconnectionRetriesLimitReached() {
-    emitEvent(EmitableEvents.ReconnectionRetriesLimitReached, emptyMap())
+    emitEvent(EmitableEvents.ReconnectionRetriesLimitReached)
   }
 }