@fishjam-cloud/react-native-client 0.1.0

package/android/src/main/java/org/membraneframework/reactnative/RNFishjamClientModule.kt

@@ -0,0 +1,294 @@
+package org.membraneframework.reactnative
+
+import expo.modules.kotlin.Promise
+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 captureDeviceId: 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 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("connect") { url: String, peerToken: String, peerMetadata: Map<String, Any>, config: ConnectConfig, promise: Promise ->
+        CoroutineScope(Dispatchers.Main).launch {
+          rnFishjamClient.connect(url, peerToken, peerMetadata, 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 { captureDeviceId: String ->
+        mutex.withLock {
+          withContext(Dispatchers.Main) {
+            rnFishjamClient.switchCamera(captureDeviceId)
+          }
+        }
+      }
+
+      AsyncFunction("getCaptureDevices") Coroutine { ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.getCaptureDevices()
+        }
+      }
+
+      AsyncFunction("handleScreencastPermission") { promise: Promise ->
+        CoroutineScope(Dispatchers.Main).launch {
+          rnFishjamClient.handleScreencastPermission(promise)
+        }
+      }
+
+      AsyncFunction("toggleScreencast") Coroutine { screencastOptions: ScreencastOptions ->
+        withContext(Dispatchers.Main) {
+          rnFishjamClient.toggleScreencast(screencastOptions)
+        }
+      }
+
+      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() }
+    }
+}

package/android/src/main/java/org/membraneframework/reactnative/Utils.kt

@@ -0,0 +1,11 @@
+package org.membraneframework.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/org/membraneframework/reactnative/VideoPreviewView.kt

@@ -0,0 +1,40 @@
+package org.membraneframework.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/org/membraneframework/reactnative/VideoPreviewViewModule.kt

@@ -0,0 +1,17 @@
+package org.membraneframework.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/org/membraneframework/reactnative/VideoRendererView.kt

@@ -0,0 +1,58 @@
+package org.membraneframework.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/org/membraneframework/reactnative/VideoRendererViewModule.kt

@@ -0,0 +1,25 @@
+package org.membraneframework.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/org/membraneframework/reactnative/VideoView.kt

@@ -0,0 +1,77 @@
+package org.membraneframework.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/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/build/withMembrane');

package/babel.config.js

@@ -0,0 +1,2 @@
+// @generated by expo-module-scripts
+module.exports = require('expo-module-scripts/babel.config.base');

package/build/RNFishjamClientModule.d.ts

@@ -0,0 +1,47 @@
+import { NativeModule } from 'react-native';
+import type { RTCStats } from './stats/types';
+import type { SimulcastConfig } from './types';
+import type { CameraConfigInternal, CaptureDevice } from './hooks/useCamera';
+import type { Participant } from './hooks/useParticipants';
+import type { ScreencastOptionsInternal } from './hooks/useScreencast';
+import type { ConnectionConfig } from './common/client';
+type Metadata = {
+    [key: string]: any;
+};
+type RNFishjamClient = {
+    connect: (url: string, peerToken: string, peerMetadata: Metadata, config: ConnectionConfig) => Promise<void>;
+    leaveRoom: () => Promise<void>;
+    startCamera: (config: CameraConfigInternal) => Promise<void>;
+    isMicrophoneOn: boolean;
+    toggleMicrophone: () => Promise<boolean>;
+    isCameraOn: boolean;
+    toggleCamera: () => Promise<boolean>;
+    flipCamera: () => Promise<void>;
+    switchCamera: (captureDeviceId: string) => Promise<void>;
+    getCaptureDevices: () => Promise<CaptureDevice[]>;
+    handleScreencastPermission: () => Promise<'granted' | 'denied'>;
+    toggleScreencast: (screencastOptions: Partial<ScreencastOptionsInternal>) => Promise<void>;
+    isScreencastOn: boolean;
+    getPeers: <PeerMetadataType extends Metadata>() => Promise<Participant<PeerMetadataType>[]>;
+    updatePeerMetadata: <MetadataType extends Metadata>(metadata: MetadataType) => Promise<void>;
+    updateVideoTrackMetadata: <MetadataType extends Metadata>(metadata: MetadataType) => Promise<void>;
+    updateAudioTrackMetadata: <MetadataType extends Metadata>(metadata: MetadataType) => Promise<void>;
+    updateScreencastTrackMetadata: <MetadataType extends Metadata>(metadata: MetadataType) => Promise<void>;
+    setOutputAudioDevice: (audioDevice: string) => Promise<void>;
+    startAudioSwitcher: () => Promise<void>;
+    stopAudioSwitcher: () => Promise<void>;
+    selectAudioSessionMode: (sessionMode: string) => Promise<void>;
+    showAudioRoutePicker: () => Promise<void>;
+    toggleScreencastTrackEncoding: (encoding: string) => Promise<SimulcastConfig>;
+    setScreencastTrackBandwidth: (bandwidth: number) => Promise<void>;
+    setScreencastTrackEncodingBandwidth: (encoding: string, bandwidth: number) => Promise<void>;
+    setTargetTrackEncoding: (trackId: string, encoding: string) => Promise<void>;
+    toggleVideoTrackEncoding: (encoding: string) => Promise<SimulcastConfig>;
+    setVideoTrackEncodingBandwidth: (encoding: string, bandwidth: number) => Promise<void>;
+    setVideoTrackBandwidth: (bandwidth: number) => Promise<void>;
+    changeWebRTCLoggingSeverity: (severity: string) => Promise<void>;
+    getStatistics: () => Promise<RTCStats>;
+};
+declare const _default: RNFishjamClient & NativeModule;
+export default _default;
+//# sourceMappingURL=RNFishjamClientModule.d.ts.map

package/build/RNFishjamClientModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RNFishjamClientModule.d.ts","sourceRoot":"","sources":["../src/RNFishjamClientModule.ts"],"names":[],"mappings":"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"}

package/build/RNFishjamClientModule.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const nativeModule = requireNativeModule('RNFishjamClient');
+export default nativeModule;
+//# sourceMappingURL=RNFishjamClientModule.js.map

package/build/RNFishjamClientModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RNFishjamClientModule.js","sourceRoot":"","sources":["../src/RNFishjamClientModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAsExD,MAAM,YAAY,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;AAE5D,eAAe,YAA8C,CAAC","sourcesContent":["import { requireNativeModule } from 'expo-modules-core';\nimport { NativeModule } from 'react-native';\n\nimport type { RTCStats } from './stats/types';\nimport type { SimulcastConfig } from './types';\nimport type { CameraConfigInternal, CaptureDevice } from './hooks/useCamera';\nimport type { Participant } from './hooks/useParticipants';\nimport type { ScreencastOptionsInternal } from './hooks/useScreencast';\nimport type { ConnectionConfig } from './common/client';\n\ntype Metadata = { [key: string]: any };\n\ntype RNFishjamClient = {\n  connect: (\n    url: string,\n    peerToken: string,\n    peerMetadata: Metadata,\n    config: ConnectionConfig,\n  ) => Promise<void>;\n  leaveRoom: () => Promise<void>;\n  startCamera: (config: CameraConfigInternal) => Promise<void>;\n  isMicrophoneOn: boolean;\n  toggleMicrophone: () => Promise<boolean>;\n  isCameraOn: boolean;\n  toggleCamera: () => Promise<boolean>;\n  flipCamera: () => Promise<void>;\n  switchCamera: (captureDeviceId: string) => Promise<void>;\n  getCaptureDevices: () => Promise<CaptureDevice[]>;\n  handleScreencastPermission: () => Promise<'granted' | 'denied'>;\n  toggleScreencast: (\n    screencastOptions: Partial<ScreencastOptionsInternal>,\n  ) => Promise<void>;\n  isScreencastOn: boolean;\n  getPeers: <PeerMetadataType extends Metadata>() => Promise<\n    Participant<PeerMetadataType>[]\n  >;\n  updatePeerMetadata: <MetadataType extends Metadata>(\n    metadata: MetadataType,\n  ) => Promise<void>;\n  updateVideoTrackMetadata: <MetadataType extends Metadata>(\n    metadata: MetadataType,\n  ) => Promise<void>;\n  updateAudioTrackMetadata: <MetadataType extends Metadata>(\n    metadata: MetadataType,\n  ) => Promise<void>;\n  updateScreencastTrackMetadata: <MetadataType extends Metadata>(\n    metadata: MetadataType,\n  ) => Promise<void>;\n  setOutputAudioDevice: (audioDevice: string) => Promise<void>;\n  startAudioSwitcher: () => Promise<void>;\n  stopAudioSwitcher: () => Promise<void>;\n  selectAudioSessionMode: (sessionMode: string) => Promise<void>;\n  showAudioRoutePicker: () => Promise<void>;\n  toggleScreencastTrackEncoding: (encoding: string) => Promise<SimulcastConfig>;\n  setScreencastTrackBandwidth: (bandwidth: number) => Promise<void>;\n  setScreencastTrackEncodingBandwidth: (\n    encoding: string,\n    bandwidth: number,\n  ) => Promise<void>;\n  setTargetTrackEncoding: (trackId: string, encoding: string) => Promise<void>;\n  toggleVideoTrackEncoding: (encoding: string) => Promise<SimulcastConfig>;\n  setVideoTrackEncodingBandwidth: (\n    encoding: string,\n    bandwidth: number,\n  ) => Promise<void>;\n  setVideoTrackBandwidth: (bandwidth: number) => Promise<void>;\n  changeWebRTCLoggingSeverity: (severity: string) => Promise<void>;\n  getStatistics: () => Promise<RTCStats>;\n};\n\nconst nativeModule = requireNativeModule('RNFishjamClient');\n\nexport default nativeModule as RNFishjamClient & NativeModule;\n"]}

package/build/common/client.d.ts

@@ -0,0 +1,19 @@
+import { GenericMetadata } from '../types';
+export type ConnectionConfig = {
+    /**
+     * Configuration for automatic reconnection
+     * sdk uses a linear backoff algorithm, that is the formula
+     * for the delay of the nth attempt is
+     * n * delayMs + initialDelayMs
+     *
+     * Pass 0 for maxAttempts to disable automatic reconnection
+     */
+    reconnectConfig?: {
+        maxAttempts?: number;
+        initialDelayMs?: number;
+        delayMs?: number;
+    };
+};
+export declare function connect<ParticipantMetadata extends GenericMetadata = GenericMetadata>(url: string, peerToken: string, peerMetadata: ParticipantMetadata, config?: ConnectionConfig): Promise<void>;
+export declare function leaveRoom(): Promise<void>;
+//# sourceMappingURL=client.d.ts.map

package/build/common/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/common/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAG3C,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,CAAC;AAEF,wBAAsB,OAAO,CAC3B,mBAAmB,SAAS,eAAe,GAAG,eAAe,EAE7D,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,mBAAmB,EACjC,MAAM,GAAE,gBAAqB,iBAG9B;AAED,wBAAsB,SAAS,kBAE9B"}

package/build/common/client.js

@@ -0,0 +1,8 @@
+import RNFishjamClientModule from '../RNFishjamClientModule';
+export async function connect(url, peerToken, peerMetadata, config = {}) {
+    await RNFishjamClientModule.connect(url, peerToken, peerMetadata, config);
+}
+export async function leaveRoom() {
+    await RNFishjamClientModule.leaveRoom();
+}
+//# sourceMappingURL=client.js.map

package/build/common/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/common/client.ts"],"names":[],"mappings":"AACA,OAAO,qBAAqB,MAAM,0BAA0B,CAAC;AAkB7D,MAAM,CAAC,KAAK,UAAU,OAAO,CAG3B,GAAW,EACX,SAAiB,EACjB,YAAiC,EACjC,SAA2B,EAAE;IAE7B,MAAM,qBAAqB,CAAC,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;AAC5E,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,SAAS;IAC7B,MAAM,qBAAqB,CAAC,SAAS,EAAE,CAAC;AAC1C,CAAC","sourcesContent":["import { GenericMetadata } from '../types';\nimport RNFishjamClientModule from '../RNFishjamClientModule';\n\nexport type ConnectionConfig = {\n  /**\n   * Configuration for automatic reconnection\n   * sdk uses a linear backoff algorithm, that is the formula\n   * for the delay of the nth attempt is\n   * n * delayMs + initialDelayMs\n   *\n   * Pass 0 for maxAttempts to disable automatic reconnection\n   */\n  reconnectConfig?: {\n    maxAttempts?: number;\n    initialDelayMs?: number;\n    delayMs?: number;\n  };\n};\n\nexport async function connect<\n  ParticipantMetadata extends GenericMetadata = GenericMetadata,\n>(\n  url: string,\n  peerToken: string,\n  peerMetadata: ParticipantMetadata,\n  config: ConnectionConfig = {},\n) {\n  await RNFishjamClientModule.connect(url, peerToken, peerMetadata, config);\n}\n\nexport async function leaveRoom() {\n  await RNFishjamClientModule.leaveRoom();\n}\n"]}

package/build/common/eventEmitter.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from 'expo-modules-core';
+export declare const ReceivableEvents: {
+    readonly IsCameraOn: "IsCameraOn";
+    readonly IsMicrophoneOn: "IsMicrophoneOn";
+    readonly IsScreencastOn: "IsScreencastOn";
+    readonly SimulcastConfigUpdate: "SimulcastConfigUpdate";
+    readonly PeersUpdate: "PeersUpdate";
+    readonly AudioDeviceUpdate: "AudioDeviceUpdate";
+    readonly SendMediaEvent: "SendMediaEvent";
+    readonly BandwidthEstimation: "BandwidthEstimation";
+    readonly ReconnectionRetriesLimitReached: "ReconnectionRetriesLimitReached";
+    readonly ReconnectionStarted: "ReconnectionStarted";
+    readonly Reconnected: "Reconnected";
+};
+export declare const eventEmitter: EventEmitter;
+//# sourceMappingURL=eventEmitter.d.ts.map

package/build/common/eventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventEmitter.d.ts","sourceRoot":"","sources":["../../src/common/eventEmitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAIrE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;CAYnB,CAAC;AAEX,eAAO,MAAM,YAAY,cAExB,CAAC"}