@fishjam-cloud/react-native-client 0.2.0 → 0.2.2

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

@@ -0,0 +1,370 @@
+package io.fishjam.reactnative
+
+import android.content.Intent
+import android.os.Build
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+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
+
+  @Field
+  val activeEncodings: List<String> = emptyList()
+}
+
+class CameraConfig : Record {
+  @Field
+  val quality: String = "VGA169"
+
+  @Field
+  val flipVideo: Boolean = false
+
+  @Field
+  val videoTrackMetadata: Map<String, Any> = emptyMap()
+
+  @Field
+  val simulcastConfig: SimulcastConfig = SimulcastConfig()
+
+  // expo-modules on Android don't support Either type
+  @Field
+  val maxBandwidthMap: Map<String, Int> = emptyMap()
+
+  @Field
+  val maxBandwidthInt: Int = 0
+
+  @Field
+  val cameraEnabled: Boolean = true
+
+  @Field
+  val cameraId: String? = null
+}
+
+class ScreencastOptions : Record {
+  @Field
+  val quality: String = "HD15"
+
+  @Field
+  val screencastMetadata: Map<String, Any> = emptyMap()
+
+  @Field
+  val simulcastConfig: SimulcastConfig = SimulcastConfig()
+
+  @Field
+  val maxBandwidthMap: Map<String, Int> = emptyMap()
+
+  @Field
+  val maxBandwidthInt: Int = 0
+}
+
+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 foregroundServiceTypes: IntArray = intArrayOf()
+}
+
+class RNFishjamClientModule : Module() {
+  override fun definition() =
+    ModuleDefinition {
+      Name("RNFishjamClient")
+
+      Events(
+        "IsCameraOn",
+        "IsMicrophoneOn",
+        "IsScreencastOn",
+        "SimulcastConfigUpdate",
+        "PeersUpdate",
+        "AudioDeviceUpdate",
+        "SendMediaEvent",
+        "BandwidthEstimation",
+        "ReconnectionRetriesLimitReached",
+        "ReconnectionStarted",
+        "Reconnected"
+      )
+
+      val rnFishjamClient =
+        RNFishjamClient { name: String, data: Map<String, Any?> ->
+          sendEvent(name, data)
+        }
+
+      val mutex = Mutex()
+
+      OnCreate {
+        rnFishjamClient.onModuleCreate(appContext)
+      }
+
+      OnDestroy {
+        rnFishjamClient.onModuleDestroy()
+      }
+
+      OnActivityDestroys {
+        rnFishjamClient.leaveRoom()
+      }
+
+      OnActivityResult { _, result ->
+        rnFishjamClient.onActivityResult(result.requestCode, result.resultCode, result.data)
+      }
+
+      AsyncFunction(
+        "joinRoom"
+      ) { url: String, participantToken: String, participantMetadata: Map<String, Any>, config: ConnectConfig, promise: Promise ->
+        CoroutineScope(Dispatchers.Main).launch {
+          rnFishjamClient.joinRoom(url, participantToken, participantMetadata, config, promise)
+        }
+      }
+
+      AsyncFunction("leaveRoom") Coroutine { ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.leaveRoom()
+        }
+      }
+
+      AsyncFunction("startCamera") Coroutine { config: CameraConfig ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.startCamera(config)
+        }
+      }
+
+      Property("isMicrophoneOn") {
+        return@Property rnFishjamClient.isMicrophoneOn
+      }
+
+      AsyncFunction("toggleMicrophone") Coroutine { ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.toggleMicrophone()
+        }
+      }
+
+      Property("isCameraOn") {
+        return@Property rnFishjamClient.isCameraOn
+      }
+
+      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("handleScreencastPermission") { promise: Promise ->
+        CoroutineScope(Dispatchers.Main).launch {
+          rnFishjamClient.handleScreencastPermission(promise)
+        }
+      }
+
+      AsyncFunction("toggleScreencast") Coroutine { screencastOptions: ScreencastOptions ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.toggleScreencast(screencastOptions)
+        }
+      }
+
+      Property("cameras") {
+        return@Property rnFishjamClient.getCaptureDevices()
+      }
+
+      Property("isScreencastOn") {
+        return@Property rnFishjamClient.isScreencastOn
+      }
+
+      AsyncFunction("getPeers") Coroutine { ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.getPeers()
+        }
+      }
+
+      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("updateAudioTrackMetadata") Coroutine { metadata: Map<String, Any> ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.updateLocalAudioTrackMetadata(metadata)
+        }
+      }
+
+      AsyncFunction("updateScreencastTrackMetadata") Coroutine { metadata: Map<String, Any> ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.updateLocalScreencastTrackMetadata(metadata)
+        }
+      }
+
+      AsyncFunction("setOutputAudioDevice") { audioDevice: String ->
+        rnFishjamClient.setOutputAudioDevice(audioDevice)
+      }
+
+      AsyncFunction("startAudioSwitcher") {
+        rnFishjamClient.startAudioSwitcher()
+      }
+
+      AsyncFunction("stopAudioSwitcher") {
+        rnFishjamClient.stopAudioSwitcher()
+      }
+
+      AsyncFunction("toggleScreencastTrackEncoding") Coroutine { encoding: String ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.toggleScreencastTrackEncoding(encoding)
+        }
+      }
+
+      AsyncFunction("setScreencastTrackBandwidth") Coroutine { bandwidth: Int ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.setScreencastTrackBandwidth(bandwidth)
+        }
+      }
+
+      AsyncFunction("setScreencastTrackEncodingBandwidth") Coroutine { encoding: String, bandwidth: Int ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.setScreencastTrackEncodingBandwidth(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 ->
+        CoroutineScope(Dispatchers.Main).launch {
+          rnFishjamClient.changeWebRTCLoggingSeverity(severity)
+        }
+      }
+
+      AsyncFunction("getStatistics") { rnFishjamClient.getStatistics() }
+
+      Function("startForegroundService") { config: ForegroundServiceConfig ->
+        if (appContext.reactContext == null) {
+          throw CodedException(message = "reactContext not found")
+        }
+
+        val channelId =
+          config.channelId
+            ?: throw CodedException(message = "Missing `channelId` for startForegroundService")
+        val channelName =
+          config.channelName
+            ?: throw CodedException(message = "Missing `channelName` for startForegroundService")
+        val notificationContent =
+          config.notificationContent
+            ?: throw CodedException(message = "Missing `notificationContent` for startForegroundService")
+        val notificationTitle =
+          config.notificationTitle
+            ?: throw CodedException(message = "Missing `notificationTitle` for startForegroundService")
+        val foregroundServiceTypes = config.foregroundServiceTypes
+
+        if (foregroundServiceTypes.isEmpty()) {
+          throw CodedException(message = "`foregroundServiceTypes` cannot be empty")
+        }
+
+        val serviceIntent =
+          Intent(
+            appContext.reactContext,
+            FishjamForegroundService::class.java
+          )
+
+        serviceIntent.putExtra("channelId", channelId)
+        serviceIntent.putExtra("channelName", channelName)
+        serviceIntent.putExtra("notificationTitle", notificationContent)
+        serviceIntent.putExtra("notificationContent", notificationTitle)
+        serviceIntent.putExtra("foregroundServiceTypes", foregroundServiceTypes)
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+          appContext.reactContext!!.startForegroundService(serviceIntent)
+        } else {
+          appContext.reactContext!!.startService(serviceIntent)
+        }
+      }
+
+      Function("stopForegroundService") {
+        if (appContext.reactContext == null) {
+          throw CodedException(message = "reactContext not found")
+        }
+
+        val serviceIntent: Intent =
+          Intent(
+            appContext.reactContext,
+            FishjamForegroundService::class.java
+          )
+
+        appContext.reactContext!!.stopService(serviceIntent)
+      }
+    }
+}

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,40 @@
+package io.fishjam.reactnative
+
+import android.content.Context
+import com.fishjamcloud.client.media.LocalVideoTrack
+import com.fishjamcloud.client.media.VideoTrack
+import expo.modules.kotlin.AppContext
+
+class VideoPreviewView(
+  context: Context,
+  appContext: AppContext
+) : VideoView(context, appContext) {
+  private var localVideoTrack: LocalVideoTrack? = null
+
+  private fun initialize() {
+    localVideoTrack =
+      RNFishjamClient.fishjamClient.getLocalEndpoint().tracks.values.firstOrNull { track ->
+        track is LocalVideoTrack
+      } as? LocalVideoTrack?
+
+    videoView.let { localVideoTrack?.addRenderer(it) }
+    super.setupTrack()
+  }
+
+  override fun dispose() {
+    videoView.let { localVideoTrack?.removeRenderer(it) }
+    super.dispose()
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    dispose()
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    initialize()
+  }
+
+  override fun getVideoTrack(): VideoTrack? = localVideoTrack
+}

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

@@ -0,0 +1,17 @@
+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) {
+        Prop("videoLayout") { view: VideoPreviewView, videoLayout: String ->
+          view.setVideoLayout(videoLayout)
+        }
+      }
+    }
+}

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

@@ -0,0 +1,58 @@
+package io.fishjam.reactnative
+
+import android.content.Context
+import com.fishjamcloud.client.media.VideoTrack
+import expo.modules.kotlin.AppContext
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class VideoRendererView(
+  context: Context,
+  appContext: AppContext
+) : VideoView(context, appContext),
+  RNFishjamClient.OnTrackUpdateListener {
+  private var activeVideoTrack: VideoTrack? = null
+  private var trackId: String? = null
+
+  init {
+    RNFishjamClient.onTracksUpdateListeners.add(this)
+  }
+
+  private fun setupTrack(videoTrack: VideoTrack) {
+    if (activeVideoTrack == videoTrack) return
+
+    activeVideoTrack?.removeRenderer(videoView)
+    activeVideoTrack = videoTrack
+
+    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.onTracksUpdateListeners.remove(this)
+    super.dispose()
+  }
+
+  override fun onTracksUpdate() {
+    update()
+  }
+
+  override fun getVideoTrack(): VideoTrack? = activeVideoTrack
+}

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

@@ -0,0 +1,25 @@
+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")
+
+      View(VideoRendererView::class) {
+        OnViewDestroys { view: VideoRendererView ->
+          view.dispose()
+        }
+
+        Prop("trackId") { view: VideoRendererView, trackId: String ->
+          view.init(trackId)
+        }
+
+        Prop("videoLayout") { view: VideoRendererView, videoLayout: String ->
+          view.setVideoLayout(videoLayout)
+        }
+      }
+    }
+}

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

@@ -0,0 +1,77 @@
+package io.fishjam.reactnative
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+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 kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import org.webrtc.RendererCommon
+
+abstract class VideoView(
+  context: Context,
+  appContext: AppContext
+) : ExpoView(context, appContext),
+  RNFishjamClient.OnLocalTrackSwitchListener {
+  protected val videoView =
+    RNFishjamClient.fishjamClient.createVideoViewRenderer().also {
+      addView(it)
+    }
+
+  private val fadeAnimation: ValueAnimator =
+    ValueAnimator.ofArgb(Color.TRANSPARENT, Color.BLACK).apply {
+      duration = 200
+      interpolator = LinearInterpolator()
+      addUpdateListener {
+        val colorValue = it.animatedValue as Int
+        foreground = ColorDrawable(colorValue)
+      }
+    }
+
+  val coroutineScope: CoroutineScope = CoroutineScope(Dispatchers.Main)
+
+  init {
+    RNFishjamClient.onLocalTrackSwitchListener.add(this)
+  }
+
+  fun setVideoLayout(videoLayout: String) {
+    val scalingType =
+      when (videoLayout) {
+        "FILL" -> RendererCommon.ScalingType.SCALE_ASPECT_FILL
+        "FIT" -> RendererCommon.ScalingType.SCALE_ASPECT_FIT
+        else -> RendererCommon.ScalingType.SCALE_ASPECT_FILL
+      }
+    videoView.setScalingType(scalingType)
+    videoView.setEnableHardwareScaler(true)
+  }
+
+  open fun dispose() {
+    videoView.release()
+  }
+
+  protected abstract fun getVideoTrack(): VideoTrack?
+
+  override suspend fun onLocalTrackWillSwitch() {
+    if (getVideoTrack() is LocalVideoTrack) {
+      fadeAnimation.start()
+    }
+  }
+
+  override suspend fun onLocalTrackSwitched() {
+    if (getVideoTrack() is LocalVideoTrack) {
+      videoView.setMirror((getVideoTrack() as? LocalVideoTrack)?.isFrontCamera() ?: false)
+      delay(500)
+      fadeAnimation.reverse()
+    }
+  }
+
+  fun setupTrack() {
+    videoView.setMirror((getVideoTrack() as? LocalVideoTrack)?.isFrontCamera() ?: false)
+  }
+}

package/expo-module.config.json

@@ -0,0 +1,17 @@
+{
+  "platforms": ["ios", "android", "web"],
+  "ios": {
+    "modules": [
+      "RNFishjamClientModule",
+      "VideoPreviewViewModule",
+      "VideoRendererViewModule"
+    ]
+  },
+  "android": {
+    "modules": [
+      "io.fishjam.reactnative.RNFishjamClientModule",
+      "io.fishjam.reactnative.VideoPreviewViewModule",
+      "io.fishjam.reactnative.VideoRendererViewModule"
+    ]
+  }
+}

package/ios/RNFishjamClient.podspec

@@ -0,0 +1,30 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'RNFishjamClient'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platform       = :ios, '13.0'
+  s.swift_version  = '5.4'
+  s.source         = { git: 'https://github.com/fishjam-cloud/mobile-client-sdk/tree/main/packages/react-native-client/ios' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  s.source_files = '**/*.{h,m,swift}'
+
+  s.dependency 'FishjamCloudClient', '>= 0.1'
+
+end

package/ios/RNFishjamClientModule.swift

@@ -97,7 +97,7 @@ public class RNFishjamClientModule: Module {
             return client
         }()
 
-        AsyncFunction("connect") {
+        AsyncFunction("joinRoom") {
             (
                 url: String, participantToken: String, participantMetadata: [String: Any], config: ConnectConfig,
                 promise: Promise
@@ -136,7 +136,7 @@ public class RNFishjamClientModule: Module {
         }
 
         AsyncFunction("switchCamera") { (cameraId: String) in
-            try rnFishjamClient.switchCamera(captureDeviceId: cameraId)
+            try rnFishjamClient.switchCamera(cameraId: cameraId)
         }
 
         Property("cameras") {