@fishjam-cloud/react-native-client 0.2.4 → 0.4.0

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

@@ -1,9 +1,6 @@
 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
@@ -84,7 +81,7 @@ class ConnectConfig : Record {
   val reconnectConfig: ReconnectConfig = ReconnectConfig()
 }
 
-class ForegroundServiceConfig : Record {
+class ForegroundServiceNotificationConfig : Record {
   @Field
   val channelId: String? = null
 
@@ -96,37 +93,32 @@ class ForegroundServiceConfig : Record {
 
   @Field
   val notificationTitle: String? = null
+}
+
+class ForegroundServicePermissionsConfig : Record {
+  @Field
+  val enableCamera: Boolean = false
 
   @Field
-  val foregroundServiceTypes: IntArray = intArrayOf()
+  val enableMicrophone: Boolean = false
+
+  @Field
+  val enableScreenSharing: Boolean = false
 }
 
 class RNFishjamClientModule : Module() {
   override fun definition() =
     ModuleDefinition {
-      Name("RNFishjamClient")
-
-      Events(
-        "IsCameraOn",
-        "IsMicrophoneOn",
-        "IsScreenShareOn",
-        "SimulcastConfigUpdate",
-        "PeersUpdate",
-        "AudioDeviceUpdate",
-        "SendMediaEvent",
-        "BandwidthEstimation",
-        "ReconnectionRetriesLimitReached",
-        "ReconnectionStarted",
-        "Reconnected",
-        "Warning"
-      )
+      val mutex = Mutex()
 
       val rnFishjamClient =
         RNFishjamClient { name: String, data: Map<String, Any?> ->
           sendEvent(name, data)
         }
 
-      val mutex = Mutex()
+      Name("RNFishjamClient")
+
+      Events(EmitableEvents.allEvents)
 
       OnCreate {
         rnFishjamClient.onModuleCreate(appContext)
@@ -144,11 +136,31 @@ class RNFishjamClientModule : Module() {
         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("isScreenShareOn") {
+        return@Property rnFishjamClient.isScreenShareOn
+      }
+
+      Property("peerStatus") {
+        return@Property rnFishjamClient.peerStatus
+      }
+
       AsyncFunction(
         "joinRoom"
-      ) { url: String, participantToken: String, participantMetadata: Map<String, Any>, config: ConnectConfig, promise: Promise ->
+      ) { url: String, peerToken: String, peerMetadata: Map<String, Any>, config: ConnectConfig, promise: Promise ->
         CoroutineScope(Dispatchers.Main).launch {
-          rnFishjamClient.joinRoom(url, participantToken, participantMetadata, config, promise)
+          rnFishjamClient.joinRoom(url, peerToken, peerMetadata, config, promise)
         }
       }
 
@@ -164,20 +176,12 @@ class RNFishjamClientModule : Module() {
         }
       }
 
-      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()
@@ -212,14 +216,6 @@ class RNFishjamClientModule : Module() {
         }
       }
 
-      Property("cameras") {
-        return@Property rnFishjamClient.getCaptureDevices()
-      }
-
-      Property("isScreenShareOn") {
-        return@Property rnFishjamClient.isScreenShareOn
-      }
-
       AsyncFunction("getPeers") Coroutine { ->
         withContext(Dispatchers.Main) {
           rnFishjamClient.getPeers()
@@ -312,60 +308,16 @@ class RNFishjamClientModule : Module() {
 
       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")
-        }
+      Function("configureForegroundService") { config: ForegroundServiceNotificationConfig ->
+        return@Function rnFishjamClient.configureForegroundService(config)
+      }
 
-        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)
-        }
+      AsyncFunction("startForegroundService") Coroutine { config: ForegroundServicePermissionsConfig ->
+        rnFishjamClient.startForegroundService(config)
       }
 
       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)
+        rnFishjamClient.stopForegroundService()
       }
     }
 }

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

@@ -4,20 +4,25 @@ import android.content.Context
 import com.fishjamcloud.client.media.LocalVideoTrack
 import com.fishjamcloud.client.media.VideoTrack
 import expo.modules.kotlin.AppContext
+import io.fishjam.reactnative.managers.LocalCameraTrackChangedListener
 
 class VideoPreviewView(
   context: Context,
   appContext: AppContext
-) : VideoView(context, appContext) {
+) : VideoView(context, appContext),
+  LocalCameraTrackChangedListener {
   private var localVideoTrack: LocalVideoTrack? = null
 
-  private fun initialize() {
+  private fun trySetLocalCameraTrack() {
     localVideoTrack =
       RNFishjamClient.fishjamClient.getLocalEndpoint().tracks.values.firstOrNull { track ->
         track is LocalVideoTrack
       } as? LocalVideoTrack?
-
     videoView.let { localVideoTrack?.addRenderer(it) }
+  }
+
+  private fun initialize() {
+    trySetLocalCameraTrack()
     super.setupTrack()
   }
 
@@ -27,14 +32,20 @@ class VideoPreviewView(
   }
 
   override fun onDetachedFromWindow() {
+    RNFishjamClient.localCameraTracksChangedListenersManager.remove(this)
     super.onDetachedFromWindow()
     dispose()
   }
 
   override fun onAttachedToWindow() {
+    RNFishjamClient.localCameraTracksChangedListenersManager.add(this)
     super.onAttachedToWindow()
     initialize()
   }
 
   override fun getVideoTrack(): VideoTrack? = localVideoTrack
+
+  override fun onLocalCameraTrackChanged() {
+    if (localVideoTrack == null) trySetLocalCameraTrack()
+  }
 }

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

@@ -9,6 +9,11 @@ class VideoPreviewViewModule : Module() {
       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

@@ -3,6 +3,7 @@ package io.fishjam.reactnative
 import android.content.Context
 import com.fishjamcloud.client.media.VideoTrack
 import expo.modules.kotlin.AppContext
+import io.fishjam.reactnative.managers.TrackUpdateListener
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -11,12 +12,12 @@ class VideoRendererView(
   context: Context,
   appContext: AppContext
 ) : VideoView(context, appContext),
-  RNFishjamClient.OnTrackUpdateListener {
+  TrackUpdateListener {
   private var activeVideoTrack: VideoTrack? = null
   private var trackId: String? = null
 
   init {
-    RNFishjamClient.onTracksUpdateListeners.add(this)
+    RNFishjamClient.trackUpdateListenersManager.add(this)
   }
 
   private fun setupTrack(videoTrack: VideoTrack) {
@@ -46,7 +47,7 @@ class VideoRendererView(
 
   override fun dispose() {
     activeVideoTrack?.removeRenderer(videoView)
-    RNFishjamClient.onTracksUpdateListeners.remove(this)
+    RNFishjamClient.trackUpdateListenersManager.add(this)
     super.dispose()
   }
 

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

@@ -11,6 +11,8 @@ class VideoRendererViewModule : Module() {
       View(VideoRendererView::class) {
         OnViewDestroys { view: VideoRendererView ->
           view.dispose()
+          RNFishjamClient.trackUpdateListenersManager.remove(view)
+          RNFishjamClient.localTracksSwitchListenerManager.remove(view)
         }
 
         Prop("trackId") { view: VideoRendererView, trackId: String ->

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

@@ -9,6 +9,7 @@ import com.fishjamcloud.client.media.LocalVideoTrack
 import com.fishjamcloud.client.media.VideoTrack
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.views.ExpoView
+import io.fishjam.reactnative.managers.LocalTrackSwitchListener
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
@@ -18,7 +19,7 @@ abstract class VideoView(
   context: Context,
   appContext: AppContext
 ) : ExpoView(context, appContext),
-  RNFishjamClient.OnLocalTrackSwitchListener {
+  LocalTrackSwitchListener {
   protected val videoView =
     RNFishjamClient.fishjamClient.createVideoViewRenderer().also {
       addView(it)
@@ -37,7 +38,7 @@ abstract class VideoView(
   val coroutineScope: CoroutineScope = CoroutineScope(Dispatchers.Main)
 
   init {
-    RNFishjamClient.onLocalTrackSwitchListener.add(this)
+    RNFishjamClient.localTracksSwitchListenerManager.add(this)
   }
 
   fun setVideoLayout(videoLayout: String) {

package/android/src/main/java/io/fishjam/reactnative/{FishjamForegroundService.kt → foregroundService/FishjamForegroundService.kt}

@@ -1,4 +1,4 @@
-package io.fishjam.reactnative
+package io.fishjam.reactnative.foregroundService
 
 import android.app.Notification
 import android.app.NotificationChannel
@@ -6,6 +6,7 @@ import android.app.NotificationManager
 import android.app.PendingIntent
 import android.app.Service
 import android.content.Intent
+import android.os.Binder
 import android.os.Build
 import android.os.IBinder
 import androidx.core.app.NotificationCompat
@@ -15,7 +16,11 @@ class FishjamForegroundService : Service() {
     private const val FOREGROUND_SERVICE_ID = 1668
   }
 
-  override fun onBind(p0: Intent?): IBinder? = null
+  private val binder = LocalBinder()
+
+  inner class LocalBinder : Binder()
+
+  override fun onBind(intent: Intent): IBinder = binder
 
   override fun onStartCommand(
     intent: Intent?,

package/android/src/main/java/io/fishjam/reactnative/foregroundService/ForegroundServiceManager.kt

@@ -0,0 +1,147 @@
+package io.fishjam.reactnative.foregroundService
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA
+import android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION
+import android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+import android.os.Build
+import android.os.IBinder
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.CodedException
+import io.fishjam.reactnative.ForegroundServiceNotificationConfig
+import io.fishjam.reactnative.ForegroundServicePermissionsConfig
+import io.fishjam.reactnative.utils.PermissionUtils
+import kotlinx.coroutines.CancellableContinuation
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+class ForegroundServiceManager(
+  private val appContext: AppContext,
+  notificationConfig: ForegroundServiceNotificationConfig
+) {
+  private val reactContext by lazy {
+    appContext.reactContext ?: throw CodedException("reactContext not found")
+  }
+  private var isServiceBound: Boolean = false
+  private var serviceConnectedContinuation: CancellableContinuation<Unit>? = null
+
+  private val serviceIntent =
+    Intent(
+      appContext.reactContext,
+      FishjamForegroundService::class.java
+    ).apply {
+      putExtra(
+        "channelId",
+        notificationConfig.channelId.orThrow("channelId")
+      )
+      putExtra(
+        "channelName",
+        notificationConfig.channelName.orThrow("channelName")
+      )
+      putExtra(
+        "notificationContent",
+        notificationConfig.notificationContent.orThrow("notificationContent")
+      )
+      putExtra(
+        "notificationTitle",
+        notificationConfig.notificationTitle.orThrow("notificationTitle")
+      )
+    }
+
+  private val connection =
+    object : ServiceConnection {
+      override fun onServiceConnected(
+        className: ComponentName,
+        service: IBinder
+      ) {
+        isServiceBound = true
+        serviceConnectedContinuation?.resume(Unit)
+        serviceConnectedContinuation = null
+      }
+
+      override fun onServiceDisconnected(arg0: ComponentName) {
+        isServiceBound = false
+        serviceConnectedContinuation?.cancel()
+        serviceConnectedContinuation = null
+      }
+    }
+
+  suspend fun startForegroundService(permissionsConfig: ForegroundServicePermissionsConfig) {
+    val foregroundServiceTypes = buildForegroundServiceTypes(permissionsConfig)
+
+    if (foregroundServiceTypes.isEmpty()) {
+      return
+    }
+
+    serviceIntent.putExtra("foregroundServiceTypes", foregroundServiceTypes.toIntArray())
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      reactContext.startForegroundService(serviceIntent)
+    } else {
+      reactContext.startService(serviceIntent)
+    }
+
+    bindServiceIfNeededAndAwait()
+  }
+
+  fun stopForegroundService() {
+    if (isServiceBound) {
+      appContext.currentActivity?.unbindService(connection)
+        ?: throw CodedException("Current activity not found")
+      isServiceBound = false
+    }
+    reactContext.stopService(serviceIntent)
+    serviceConnectedContinuation?.cancel()
+    serviceConnectedContinuation = null
+  }
+
+  private fun buildForegroundServiceTypes(permissionsConfig: ForegroundServicePermissionsConfig): List<Int> =
+    buildList {
+      if (permissionsConfig.enableCamera) {
+        addIfPermissionGranted(
+          FOREGROUND_SERVICE_TYPE_CAMERA,
+          "camera",
+          PermissionUtils::hasCameraPermission
+        )
+      }
+      if (permissionsConfig.enableMicrophone) {
+        addIfPermissionGranted(
+          FOREGROUND_SERVICE_TYPE_MICROPHONE,
+          "microphone",
+          PermissionUtils::hasMicrophonePermission
+        )
+      }
+      if (permissionsConfig.enableScreenSharing) add(FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION)
+    }
+
+  private fun MutableList<Int>.addIfPermissionGranted(
+    serviceType: Int,
+    permissionName: String,
+    hasPermission: (AppContext) -> Boolean
+  ) {
+    if (!hasPermission(appContext)) {
+      throw CodedException("Cannot start a $permissionName foreground service without $permissionName permission.")
+    }
+    add(serviceType)
+  }
+
+  private suspend fun bindServiceIfNeededAndAwait() =
+    suspendCancellableCoroutine { continuation ->
+      if (!isServiceBound) {
+        serviceConnectedContinuation = continuation
+        runCatching {
+          appContext.currentActivity?.bindService(serviceIntent, connection, Context.BIND_AUTO_CREATE)
+        }.onFailure { error ->
+          continuation.cancel(CodedException("Failed to bind service: ${error.message}"))
+        }
+      } else {
+        continuation.resume(Unit)
+        serviceConnectedContinuation = null
+      }
+    }
+}
+
+private fun String?.orThrow(fieldName: String): String = this ?: throw CodedException("Missing `$fieldName` for startForegroundService")

package/android/src/main/java/io/fishjam/reactnative/managers/LocalCameraTracksChangedListenersManager.kt

@@ -0,0 +1,21 @@
+package io.fishjam.reactnative.managers
+
+interface LocalCameraTrackChangedListener {
+  fun onLocalCameraTrackChanged()
+}
+
+class LocalCameraTracksChangedListenersManager {
+  private var listeners: MutableList<LocalCameraTrackChangedListener> = mutableListOf()
+
+  fun add(listener: LocalCameraTrackChangedListener) {
+    listeners.add(listener)
+  }
+
+  fun remove(listener: LocalCameraTrackChangedListener) {
+    listeners.remove(listener)
+  }
+
+  fun notifyListeners() {
+    for (listener in listeners) listener.onLocalCameraTrackChanged()
+  }
+}

package/android/src/main/java/io/fishjam/reactnative/managers/LocalTracksSwitchListenersManager.kt

@@ -0,0 +1,27 @@
+package io.fishjam.reactnative.managers
+
+interface LocalTrackSwitchListener {
+  suspend fun onLocalTrackWillSwitch()
+
+  suspend fun onLocalTrackSwitched()
+}
+
+class LocalTracksSwitchListenersManager {
+  private val listeners: MutableList<LocalTrackSwitchListener> = mutableListOf()
+
+  fun add(listener: LocalTrackSwitchListener) {
+    listeners.add(listener)
+  }
+
+  fun remove(listener: LocalTrackSwitchListener) {
+    listeners.remove(listener)
+  }
+
+  suspend fun notifyWillSwitch() {
+    for (listener in listeners) listener.onLocalTrackWillSwitch()
+  }
+
+  suspend fun notifySwitched() {
+    for (listener in listeners) listener.onLocalTrackSwitched()
+  }
+}

package/android/src/main/java/io/fishjam/reactnative/managers/TracksUpdateListenersManager.kt

@@ -0,0 +1,21 @@
+package io.fishjam.reactnative.managers
+
+interface TrackUpdateListener {
+  fun onTracksUpdate()
+}
+
+class TracksUpdateListenersManager {
+  private val listeners: MutableList<TrackUpdateListener> = mutableListOf()
+
+  fun add(listener: TrackUpdateListener) {
+    listeners.add(listener)
+  }
+
+  fun remove(listener: TrackUpdateListener) {
+    listeners.remove(listener)
+  }
+
+  fun notifyListeners() {
+    for (listener in listeners) listener.onTracksUpdate()
+  }
+}

package/android/src/main/java/io/fishjam/reactnative/utils/PermissionUtils.kt

@@ -0,0 +1,45 @@
+package io.fishjam.reactnative.utils
+
+import android.Manifest
+import android.content.pm.PackageManager
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.interfaces.permissions.PermissionsStatus
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.Exceptions
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+object PermissionUtils {
+  fun hasCameraPermission(appContext: AppContext?): Boolean = hasPermission(appContext, Manifest.permission.CAMERA)
+
+  fun hasMicrophonePermission(appContext: AppContext?): Boolean = hasPermission(appContext, Manifest.permission.RECORD_AUDIO)
+
+  suspend fun requestCameraPermission(appContext: AppContext?): Boolean = requestAccessIfNeeded(appContext, Manifest.permission.CAMERA)
+
+  suspend fun requestMicrophonePermission(appContext: AppContext?): Boolean =
+    requestAccessIfNeeded(appContext, Manifest.permission.RECORD_AUDIO)
+
+  private suspend fun requestAccessIfNeeded(
+    appContext: AppContext?,
+    permission: String
+  ): Boolean {
+    val permissionsManager: Permissions =
+      appContext?.permissions
+        ?: throw Exceptions.PermissionsModuleNotFound()
+
+    if (hasPermission(appContext, permission)) {
+      return true
+    }
+
+    return suspendCoroutine { continuation ->
+      permissionsManager.askForPermissions({ result ->
+        continuation.resume(result[permission]?.status == PermissionsStatus.GRANTED)
+      }, permission)
+    }
+  }
+
+  private fun hasPermission(
+    appContext: AppContext?,
+    permission: String
+  ): Boolean = appContext?.reactContext?.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED
+}

package/build/RNFishjamClientModule.d.ts

@@ -1,29 +1,34 @@
 import { EventEmitter } from 'expo-modules-core';
 import { NativeModule } from 'react-native';
-import type { RTCStats } from './stats/types';
-import type { ForegroundServiceOptions, SimulcastConfig } from './types';
+import type { RTCStats } from './debug/stats/types';
+import type { SimulcastConfig } from './types';
 import type { CameraConfigInternal, Camera } from './hooks/useCamera';
-import type { Participant } from './hooks/useParticipants';
+import type { Peer } from './hooks/usePeers';
 import type { ScreenShareOptionsInternal } from './hooks/useScreenShare';
 import type { ConnectionConfig } from './common/client';
+import { PeerStatus } from './hooks/usePeerStatus';
+import { ForegroundServiceNotificationConfig, ForegroundServicePermissionsConfigInternal } from './hooks/useForegroundService';
 type Metadata = {
     [key: string]: any;
 };
 type RNFishjamClient = {
-    joinRoom: (url: string, participantToken: string, participantMetadata: Metadata, config: ConnectionConfig) => Promise<void>;
+    isMicrophoneOn: boolean;
+    isCameraOn: boolean;
+    isScreenShareOn: boolean;
+    isAppScreenShareOn: boolean;
+    cameras: ReadonlyArray<Camera>;
+    peerStatus: PeerStatus;
+    joinRoom: (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: (cameraId: string) => Promise<void>;
-    cameras: ReadonlyArray<Camera>;
     handleScreenSharePermission: () => Promise<'granted' | 'denied'>;
     toggleScreenShare: (screenShareOptions: Partial<ScreenShareOptionsInternal>) => Promise<void>;
-    isScreenShareOn: boolean;
-    getPeers: <PeerMetadataType extends Metadata>() => Promise<Participant<PeerMetadataType>[]>;
+    toggleAppScreenShare: (screenShareOptions: Partial<ScreenShareOptionsInternal>) => Promise<void>;
+    getPeers: <PeerMetadataType extends Metadata>() => Promise<Peer<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>;
@@ -42,7 +47,8 @@ type RNFishjamClient = {
     setVideoTrackBandwidth: (bandwidth: number) => Promise<void>;
     changeWebRTCLoggingSeverity: (severity: string) => Promise<void>;
     getStatistics: () => Promise<RTCStats>;
-    startForegroundService: (options: ForegroundServiceOptions) => void;
+    configureForegroundService: (config: ForegroundServiceNotificationConfig) => void;
+    startForegroundService: (config: ForegroundServicePermissionsConfigInternal) => Promise<void>;
     stopForegroundService: () => void;
 };
 export declare const nativeModuleEventEmitter: EventEmitter;