@fishjam-cloud/react-native-client 0.24.0 → 0.25.0-rc.2

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

@@ -1,358 +0,0 @@
-package io.fishjam.reactnative
-
-import android.Manifest
-import expo.modules.interfaces.permissions.Permissions
-import expo.modules.kotlin.Promise
-import expo.modules.kotlin.exception.Exceptions
-import expo.modules.kotlin.functions.Coroutine
-import expo.modules.kotlin.modules.Module
-import expo.modules.kotlin.modules.ModuleDefinition
-import expo.modules.kotlin.records.Field
-import expo.modules.kotlin.records.Record
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
-
-class SimulcastConfig : Record {
-  @Field
-  val enabled: Boolean = false
-}
-
-class CameraConfig : Record {
-  @Field
-  val quality: String = "VGA169"
-
-  @Field
-  val flipDimensions: Boolean = false
-
-  @Field
-  val videoTrackMetadata: Map<String, Any> = emptyMap()
-
-  @Field
-  val simulcastConfig: SimulcastConfig = SimulcastConfig()
-
-  @Field
-  val cameraEnabled: Boolean = true
-
-  @Field
-  val cameraId: String? = null
-}
-
-class ScreenShareOptions : Record {
-  @Field
-  val quality: String = "HD15"
-
-  @Field
-  val screenShareMetadata: Map<String, Any> = emptyMap()
-
-  @Field
-  val simulcastConfig: SimulcastConfig = SimulcastConfig()
-}
-
-class ReconnectConfig : Record {
-  @Field
-  val maxAttempts: Int = 5
-
-  @Field
-  val initialDelayMs: Long = 1000
-
-  @Field
-  val delayMs: Long = 1000
-}
-
-class ConnectConfig : Record {
-  @Field
-  val reconnectConfig: ReconnectConfig = ReconnectConfig()
-}
-
-class ForegroundServiceConfig : Record {
-  @Field
-  val channelId: String? = null
-
-  @Field
-  val channelName: String? = null
-
-  @Field
-  val notificationContent: String? = null
-
-  @Field
-  val notificationTitle: String? = null
-
-  @Field
-  val enableCamera: Boolean? = null
-
-  @Field
-  val enableMicrophone: Boolean? = null
-}
-
-class RNFishjamClientModule : Module() {
-  override fun definition() =
-    ModuleDefinition {
-      val mutex = Mutex()
-
-      val rnFishjamClient =
-        RNFishjamClient { name, data ->
-          sendEvent(name, data)
-        }
-
-      Name("RNFishjamClient")
-
-      Events(EmitableEvent.allEvents)
-
-      OnCreate {
-        rnFishjamClient.onModuleCreate(appContext)
-      }
-
-      OnDestroy {
-        rnFishjamClient.onModuleDestroy()
-      }
-
-      OnActivityDestroys {
-        rnFishjamClient.leaveRoom()
-      }
-
-      OnActivityResult { _, result ->
-        rnFishjamClient.onActivityResult(result.requestCode, result.resultCode, result.data)
-      }
-
-      Property("isCameraOn") {
-        return@Property rnFishjamClient.isCameraOn
-      }
-
-      Property("isMicrophoneOn") {
-        return@Property rnFishjamClient.isMicrophoneOn
-      }
-
-      Property("cameras") {
-        return@Property rnFishjamClient.getCaptureDevices()
-      }
-
-      Property("currentCamera") {
-        return@Property rnFishjamClient.getCurrentCaptureDevice()
-      }
-
-      Property("isScreenShareOn") {
-        return@Property rnFishjamClient.isScreenShareOn
-      }
-
-      Property("peerStatus") {
-        return@Property rnFishjamClient.peerStatus.status
-      }
-
-      Property("reconnectionStatus") {
-        return@Property rnFishjamClient.reconnectionStatus.status
-      }
-
-      Property("isCameraInitialized") {
-        return@Property rnFishjamClient.isCameraInitialized
-      }
-
-      Function("getPeers") {
-        return@Function rnFishjamClient.getPeers()
-      }
-
-      AsyncFunction(
-        "joinRoom"
-      ) { url: String, peerToken: String, peerMetadata: Map<String, Any>, config: ConnectConfig, promise: Promise ->
-        CoroutineScope(Dispatchers.Main).launch {
-          rnFishjamClient.joinRoom(url, peerToken, peerMetadata, config, promise)
-        }
-      }
-
-      AsyncFunction("leaveRoom") Coroutine { ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.leaveRoom()
-        }
-      }
-
-      AsyncFunction("startCamera") Coroutine { config: CameraConfig ->
-        mutex.withLock {
-          return@Coroutine withContext(Dispatchers.Main) {
-            return@withContext rnFishjamClient.startCamera(config)
-          }
-        }
-      }
-
-      AsyncFunction("toggleMicrophone") Coroutine { ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.toggleMicrophone()
-        }
-      }
-
-      AsyncFunction("startMicrophone") Coroutine { ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.startMicrophone()
-        }
-      }
-
-      AsyncFunction("stopMicrophone") Coroutine { ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.stopMicrophone()
-        }
-      }
-
-      AsyncFunction("toggleCamera") Coroutine { ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.toggleCamera()
-        }
-      }
-
-      AsyncFunction("flipCamera") Coroutine { ->
-        mutex.withLock {
-          withContext(Dispatchers.Main) {
-            rnFishjamClient.flipCamera()
-          }
-        }
-      }
-
-      AsyncFunction("switchCamera") Coroutine { cameraId: String ->
-        mutex.withLock {
-          withContext(Dispatchers.Main) {
-            rnFishjamClient.switchCamera(cameraId)
-          }
-        }
-      }
-
-      AsyncFunction("handleScreenSharePermission") { promise: Promise ->
-        CoroutineScope(Dispatchers.Main).launch {
-          rnFishjamClient.handleScreenSharePermission(promise)
-        }
-      }
-
-      AsyncFunction("toggleScreenShare") Coroutine { screenShareOptions: ScreenShareOptions ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.toggleScreenShare(screenShareOptions)
-        }
-      }
-
-      AsyncFunction("updatePeerMetadata") Coroutine { metadata: Map<String, Any> ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.updatePeerMetadata(metadata)
-        }
-      }
-
-      AsyncFunction("updateVideoTrackMetadata") Coroutine { metadata: Map<String, Any> ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.updateLocalVideoTrackMetadata(metadata)
-        }
-      }
-
-      AsyncFunction("updateScreenShareTrackMetadata") Coroutine { metadata: Map<String, Any> ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.updateLocalScreenShareTrackMetadata(metadata)
-        }
-      }
-
-      AsyncFunction("setOutputAudioDevice") { audioDevice: String ->
-        rnFishjamClient.setOutputAudioDevice(audioDevice)
-      }
-
-      AsyncFunction("startAudioSwitcher") {
-        rnFishjamClient.startAudioSwitcher()
-      }
-
-      AsyncFunction("stopAudioSwitcher") {
-        rnFishjamClient.stopAudioSwitcher()
-      }
-
-      AsyncFunction("toggleScreenShareTrackEncoding") Coroutine { encoding: String ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.toggleScreenShareTrackEncoding(encoding)
-        }
-      }
-
-      AsyncFunction("setScreenShareTrackBandwidth") Coroutine { bandwidth: Int ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.setScreenShareTrackBandwidth(bandwidth)
-        }
-      }
-
-      AsyncFunction("setScreenShareTrackEncodingBandwidth") Coroutine { encoding: String, bandwidth: Int ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.setScreenShareTrackEncodingBandwidth(encoding, bandwidth)
-        }
-      }
-
-      AsyncFunction("setTargetTrackEncoding") Coroutine { trackId: String, encoding: String ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.setTargetTrackEncoding(trackId, encoding)
-        }
-      }
-
-      AsyncFunction("toggleVideoTrackEncoding") Coroutine { encoding: String ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.toggleVideoTrackEncoding(encoding)
-        }
-      }
-
-      AsyncFunction("setVideoTrackEncodingBandwidth") Coroutine { encoding: String, bandwidth: Int ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.setVideoTrackEncodingBandwidth(encoding, bandwidth)
-        }
-      }
-
-      AsyncFunction("setVideoTrackBandwidth") Coroutine { bandwidth: Int ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.setVideoTrackBandwidth(bandwidth)
-        }
-      }
-
-      AsyncFunction("changeWebRTCLoggingSeverity") Coroutine { severity: String ->
-        withContext(Dispatchers.Main) {
-          rnFishjamClient.changeWebRTCLoggingSeverity(severity)
-        }
-      }
-
-      AsyncFunction("getStatistics") Coroutine { ->
-        return@Coroutine rnFishjamClient.getStatistics()
-      }
-
-      AsyncFunction("startForegroundService") Coroutine { config: ForegroundServiceConfig ->
-        rnFishjamClient.startForegroundService(config)
-      }
-
-      Function("stopForegroundService") {
-        rnFishjamClient.stopForegroundService()
-      }
-
-      AsyncFunction("requestCameraPermissionsAsync") { promise: Promise ->
-        Permissions.askForPermissionsWithPermissionsManager(
-          permissionsManager,
-          promise,
-          Manifest.permission.CAMERA
-        )
-      }
-
-      AsyncFunction("requestMicrophonePermissionsAsync") { promise: Promise ->
-        Permissions.askForPermissionsWithPermissionsManager(
-          permissionsManager,
-          promise,
-          Manifest.permission.RECORD_AUDIO
-        )
-      }
-
-      AsyncFunction("getCameraPermissionsAsync") { promise: Promise ->
-        Permissions.getPermissionsWithPermissionsManager(
-          permissionsManager,
-          promise,
-          Manifest.permission.CAMERA
-        )
-      }
-
-      AsyncFunction("getMicrophonePermissionsAsync") { promise: Promise ->
-        Permissions.getPermissionsWithPermissionsManager(
-          permissionsManager,
-          promise,
-          Manifest.permission.RECORD_AUDIO
-        )
-      }
-
-
-    }
-
-  private val permissionsManager: Permissions
-    get() = appContext.permissions ?: throw Exceptions.PermissionsModuleNotFound()
-}

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

@@ -1,11 +0,0 @@
-package io.fishjam.reactnative
-
-import com.fishjamcloud.client.models.TrackEncoding
-
-internal fun String.toTrackEncoding(): TrackEncoding =
-  when (this) {
-    "l" -> TrackEncoding.L
-    "m" -> TrackEncoding.M
-    "h" -> TrackEncoding.H
-    else -> throw IllegalArgumentException("Invalid encoding specified: $this")
-  }

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

@@ -1,40 +0,0 @@
-package io.fishjam.reactnative
-
-import android.content.Context
-import android.util.Log
-import com.fishjamcloud.client.media.LocalVideoTrack
-import com.fishjamcloud.client.models.Dimensions
-import expo.modules.kotlin.AppContext
-import io.fishjam.reactnative.managers.LocalCameraTrackChangedListener
-
-class VideoPreviewView(
-  context: Context,
-  appContext: AppContext
-) : VideoRendererView(context, appContext),
-  LocalCameraTrackChangedListener {
-  private fun trySetLocalCameraTrack() {
-    (
-      RNFishjamClient.fishjamClient.getLocalEndpoint().tracks.values.firstOrNull { track ->
-        track is LocalVideoTrack
-      } as? LocalVideoTrack?
-    )?.let {
-      init(it.id())
-    }
-  }
-
-  override fun onDetachedFromWindow() {
-    RNFishjamClient.localCameraTracksChangedListenersManager.remove(this)
-    super.onDetachedFromWindow()
-  }
-
-  override fun onAttachedToWindow() {
-    RNFishjamClient.localCameraTracksChangedListenersManager.add(this)
-    activeVideoTrack?.removeRenderer(videoView)
-    super.onAttachedToWindow()
-    trySetLocalCameraTrack()
-  }
-
-  override fun onLocalCameraTrackChanged() {
-    if (activeVideoTrack == null) trySetLocalCameraTrack()
-  }
-}

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

@@ -1,22 +0,0 @@
-package io.fishjam.reactnative
-
-import expo.modules.kotlin.modules.Module
-import expo.modules.kotlin.modules.ModuleDefinition
-
-class VideoPreviewViewModule : Module() {
-  override fun definition() =
-    ModuleDefinition {
-      Name("VideoPreviewViewModule")
-
-      View(VideoPreviewView::class) {
-        OnViewDestroys { view: VideoPreviewView ->
-          view.dispose()
-          RNFishjamClient.localTracksSwitchListenerManager.remove(view)
-        }
-
-        Prop("videoLayout") { view: VideoPreviewView, videoLayout: String ->
-          view.setVideoLayout(videoLayout)
-        }
-      }
-    }
-}

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

@@ -1,76 +0,0 @@
-package io.fishjam.reactnative
-
-import android.content.Context
-import com.fishjamcloud.client.media.VideoTrack
-import com.fishjamcloud.client.media.VideoTrackListener
-import com.fishjamcloud.client.models.Dimensions
-import expo.modules.kotlin.AppContext
-import io.fishjam.reactnative.managers.TrackUpdateListener
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-
-open class VideoRendererView(
-  context: Context,
-  appContext: AppContext
-) : VideoView(context, appContext),
-  TrackUpdateListener,
-  VideoTrackListener {
-  protected var activeVideoTrack: VideoTrack? = null
-  private var trackId: String? = null
-
-  init {
-    RNFishjamClient.trackUpdateListenersManager.add(this)
-  }
-
-  private fun setupTrack(videoTrack: VideoTrack) {
-    if (activeVideoTrack == videoTrack) return
-
-    activeVideoTrack?.removeRenderer(videoView)
-    activeVideoTrack = videoTrack
-
-    videoTrack.setDimensionsListener(this)
-    videoTrack.addRenderer(videoView)
-
-    super.setupTrack()
-  }
-
-  private fun update() {
-    CoroutineScope(Dispatchers.Main).launch {
-      val peers = RNFishjamClient.getAllPeers()
-      val endpoint = peers.firstOrNull { it.tracks[trackId] != null } ?: return@launch
-      val videoTrack = endpoint.tracks[trackId] as? VideoTrack ?: return@launch
-      setupTrack(videoTrack)
-    }
-  }
-
-  fun init(trackId: String) {
-    this.trackId = trackId
-    update()
-  }
-
-  override fun dispose() {
-    activeVideoTrack?.removeRenderer(videoView)
-    RNFishjamClient.trackUpdateListenersManager.remove(this)
-    super.dispose()
-  }
-
-  override fun onTracksUpdate() {
-    update()
-  }
-
-  override fun getVideoTrack(): VideoTrack? = activeVideoTrack
-
-  override fun onDimensionsChanged(dimensions: Dimensions) {
-    if (trackId == null) return
-
-    RNFishjamClient.sendEvent(
-      EmitableEvent.trackAspectRatioUpdated(
-        trackId!!,
-        dimensions.aspectRatio
-      )
-    )
-  }
-
-  fun getTrackId(): String? = trackId
-}

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

@@ -1,33 +0,0 @@
-package io.fishjam.reactnative
-
-import expo.modules.kotlin.modules.Module
-import expo.modules.kotlin.modules.ModuleDefinition
-
-class VideoRendererViewModule : Module() {
-  override fun definition() =
-    ModuleDefinition {
-      Name("VideoRendererViewModule")
-
-      Events("TrackAspectRatioUpdated")
-
-      View(VideoRendererView::class) {
-        OnViewDestroys { view: VideoRendererView ->
-          view.dispose()
-          RNFishjamClient.trackUpdateListenersManager.remove(view)
-          RNFishjamClient.localTracksSwitchListenerManager.remove(view)
-        }
-
-        Prop("trackId") { view, trackId: String ->
-          view.init(trackId)
-        }
-
-        Prop("videoLayout") { view, videoLayout: String ->
-          view.setVideoLayout(videoLayout)
-        }
-
-        Prop("skipRenderOutsideVisibleArea") { view, skipRenderOutsideVisibleArea: Boolean ->
-          view.checkVisibilityDelayMillis = if (skipRenderOutsideVisibleArea) 1000 else null
-        }
-      }
-    }
-}