@fishjam-cloud/react-native-client 0.2.1 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fishjam-cloud/react-native-client",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "A React Native client for Fishjam Cloud",
   "author": "Fishjam Cloud Team",
   "license": "Apache-2.0",
@@ -78,12 +78,12 @@
     "testEnvironment": "jsdom"
   },
   "files": [
-    "build/",
+    "build/**",
     "android/build.gradle",
-    "android/src/",
+    "android/src/**",
     "ios/*.swift",
     "ios/RNFishjamClient.podspec",
-    "plugin/build/",
+    "plugin/build/**",
     "app.plugin.js",
     "expo-module.config.json",
     "README.md",

package/plugin/build/types.d.ts

@@ -0,0 +1,9 @@
+export type FishjamPluginOptions = {
+    android: {
+        enableForegroundService: boolean;
+    };
+    ios: {
+        iphoneDeploymentTarget?: string;
+        enableScreensharing: boolean;
+    };
+};

package/plugin/build/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/plugin/build/withFishjam.d.ts

@@ -0,0 +1,4 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { FishjamPluginOptions } from './types';
+declare const withFishjam: ConfigPlugin<FishjamPluginOptions>;
+export default withFishjam;

package/plugin/build/withFishjam.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const withFishjamAndroid_1 = require("./withFishjamAndroid");
+const withFishjamIos_1 = __importDefault(require("./withFishjamIos"));
+const withFishjam = (config, options) => {
+    (0, withFishjamAndroid_1.withFishjamAndroid)(config, options);
+    (0, withFishjamIos_1.default)(config, options);
+    return config;
+};
+exports.default = withFishjam;

package/plugin/build/withFishjamAndroid.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { FishjamPluginOptions } from './types';
+export declare const withFishjamAndroid: ConfigPlugin<FishjamPluginOptions>;

package/plugin/build/withFishjamAndroid.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFishjamAndroid = void 0;
+const config_plugins_1 = require("@expo/config-plugins");
+const Manifest_1 = require("@expo/config-plugins/build/android/Manifest");
+const withFishjamForegroundService = (config) => {
+    return (0, config_plugins_1.withAndroidManifest)(config, async (config) => {
+        const mainApplication = (0, Manifest_1.getMainApplicationOrThrow)(config.modResults);
+        mainApplication.service = mainApplication.service || [];
+        const newService = {
+            $: {
+                'android:name': 'io.fishjam.reactnative.FishjamForegroundService',
+                'android:foregroundServiceType': 'camera|microphone|mediaProjection',
+            },
+        };
+        const existingServiceIndex = mainApplication.service.findIndex((service) => service.$['android:name'] === newService.$['android:name']);
+        if (existingServiceIndex !== -1) {
+            mainApplication.service[existingServiceIndex] = newService;
+        }
+        else {
+            mainApplication.service.push(newService);
+        }
+        return config;
+    });
+};
+const withFishjamAndroid = (config, { android: { enableForegroundService } }) => {
+    if (enableForegroundService) {
+        config = withFishjamForegroundService(config);
+    }
+    return config;
+};
+exports.withFishjamAndroid = withFishjamAndroid;