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

package/README.md

@@ -6,11 +6,11 @@
 
 # Installation
 
-Check out the [installation](https://fishjam-cloud.github.io/documentation/guide/react-native/installation) section of our docs for the detailed installation instructions.
+Check out the [installation](https://docs.fishjam.io/react-native/installation) section of our docs for the detailed installation instructions.
 
 # Documentation
 
-Check out our [documentation](https://fishjam-cloud.github.io/documentation/) on how Fishjam Cloud work and how to integrate our service with your app.
+Check out our [documentation](https://docs.fishjam.io/) on how Fishjam Cloud work and how to integrate our service with your app.
 
 There is also [API documentation](https://fishjam-cloud.github.io/mobile-client-sdk/modules/_fishjam_cloud_react_native_client.html) available.
 

package/android/build.gradle

@@ -2,7 +2,7 @@ apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
-def packageVersion = '0.3.0'
+def packageVersion = '0.4.0'
 
 group = 'io.fishjam.reactnative'
 version = "${packageVersion}"
@@ -86,6 +86,6 @@ dependencies {
     // update version number when releasing
     implementation "com.github.fishjam-cloud:mobile-client-sdk:${packageVersion}"
   }
-  api 'com.github.davidliu:audioswitch:8edf84ee46cdbc84c2b7725aa8f8d66363e19876'
+  implementation 'com.twilio:audioswitch:1.2.0'
   implementation 'androidx.appcompat:appcompat:1.6.1'
 }

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

@@ -11,8 +11,7 @@ class ConnectionError(
   reason: AuthError
 ) : CodedException(message = "Connection error: ${reason.error}")
 
-class MissingScreenSharePermission :
-  CodedException(message = "No permission to start screen share, call handleScreenSharePermission first.")
+class MissingScreenSharePermission : CodedException(message = "No permission to start screen share.")
 
 class ClientNotConnectedError : CodedException(message = "Client not connected to server yet. Make sure to call connect() first!")
 

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

@@ -27,6 +27,11 @@ import com.twilio.audioswitch.AudioDevice
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.CodedException
+import io.fishjam.reactnative.foregroundService.ForegroundServiceManager
+import io.fishjam.reactnative.managers.LocalCameraTracksChangedListenersManager
+import io.fishjam.reactnative.managers.LocalTracksSwitchListenersManager
+import io.fishjam.reactnative.managers.TracksUpdateListenersManager
+import io.fishjam.reactnative.utils.PermissionUtils
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -70,24 +75,15 @@ class RNFishjamClient(
       emitEvent(event, mapOf(event.name to value))
     }
 
-  interface OnTrackUpdateListener {
-    fun onTracksUpdate()
-  }
+  private var foregroundServiceManager: ForegroundServiceManager? = null
 
-  interface OnLocalTrackSwitchListener {
-    suspend fun onLocalTrackWillSwitch()
+  companion object {
+    val trackUpdateListenersManager = TracksUpdateListenersManager()
 
-    suspend fun onLocalTrackSwitched()
-  }
+    val localTracksSwitchListenerManager = LocalTracksSwitchListenersManager()
 
-  interface OnLocalCameraTrackChangedListener {
-    fun onLocalCameraTrackChanged()
-  }
+    val localCameraTracksChangedListenersManager = LocalCameraTracksChangedListenersManager()
 
-  companion object {
-    var onTracksUpdateListeners: MutableList<OnTrackUpdateListener> = mutableListOf()
-    val onLocalTrackSwitchListener: MutableList<OnLocalTrackSwitchListener> = mutableListOf()
-    var localCameraTrackListeners: MutableList<OnLocalCameraTrackChangedListener> = mutableListOf()
     lateinit var fishjamClient: FishjamClient
 
     fun getAllPeers(): List<Peer> {
@@ -253,12 +249,12 @@ class RNFishjamClient(
   ) {
     peerStatus = PeerStatus.connecting
     connectPromise = promise
-    localUserMetadata = peerMetadata
+    localUserMetadata = mapOf("server" to emptyMap(), "peer" to peerMetadata)
     fishjamClient.connect(
       com.fishjamcloud.client.ConnectConfig(
         url,
         peerToken,
-        peerMetadata,
+        localUserMetadata,
         ReconnectConfig(
           config.reconnectConfig.maxAttempts,
           config.reconnectConfig.initialDelayMs,
@@ -287,6 +283,11 @@ class RNFishjamClient(
       emitWarning("Camera already started. You may only call startCamera once before leaveRoom is called.")
       return
     }
+    if (!PermissionUtils.requestCameraPermission(appContext)) {
+      emitWarning("Camera permission not granted.")
+      return
+    }
+
     val cameraTrack = createCameraTrack(config)
     setCameraTrackState(cameraTrack, config.cameraEnabled)
     emitEndpoints()
@@ -311,7 +312,7 @@ class RNFishjamClient(
     isCameraOn = isEnabled
     val event = EmitableEvents.IsCameraOn
     emitEvent(event, mapOf(event.name to isEnabled))
-    localCameraTrackListeners.forEach { it.onLocalCameraTrackChanged() }
+    localCameraTracksChangedListenersManager.notifyListeners()
   }
 
   fun toggleCamera(): Boolean {
@@ -322,21 +323,24 @@ class RNFishjamClient(
 
   suspend fun flipCamera() {
     ensureVideoTrack()
-    onLocalTrackSwitchListener.forEach { it.onLocalTrackWillSwitch() }
+    localTracksSwitchListenerManager.notifyWillSwitch()
     getLocalVideoTrack()?.flipCamera()
-    onLocalTrackSwitchListener.forEach { it.onLocalTrackSwitched() }
+    localTracksSwitchListenerManager.notifySwitched()
   }
 
   suspend fun switchCamera(cameraId: String) {
     ensureVideoTrack()
-    onLocalTrackSwitchListener.forEach { it.onLocalTrackWillSwitch() }
+    localTracksSwitchListenerManager.notifyWillSwitch()
     getLocalVideoTrack()?.switchCamera(cameraId)
-    onLocalTrackSwitchListener.forEach {
-      it.onLocalTrackSwitched()
-    }
+    localTracksSwitchListenerManager.notifySwitched()
   }
 
   private suspend fun startMicrophone() {
+    if (!PermissionUtils.requestMicrophonePermission(appContext)) {
+      emitWarning("Microphone permission not granted.")
+      return
+    }
+
     val microphoneTrack = fishjamClient.createAudioTrack(emptyMap())
     setMicrophoneTrackState(microphoneTrack, true)
     emitEndpoints()
@@ -376,6 +380,24 @@ class RNFishjamClient(
     }
   }
 
+  fun configureForegroundService(config: ForegroundServiceNotificationConfig) {
+    if (foregroundServiceManager == null) {
+      foregroundServiceManager = ForegroundServiceManager(appContext!!, config)
+    }
+  }
+
+  suspend fun startForegroundService(config: ForegroundServicePermissionsConfig) {
+    if (foregroundServiceManager == null) {
+      throw CodedException("Foreground service not configured.")
+    }
+
+    foregroundServiceManager?.startForegroundService(config)
+  }
+
+  fun stopForegroundService() {
+    foregroundServiceManager?.stopForegroundService()
+  }
+
   suspend fun toggleScreenShare(screenShareOptions: ScreenShareOptions) {
     this.screenShareMetadata = screenShareOptions.screenShareMetadata
     this.screenShareQuality = screenShareOptions.quality
@@ -549,7 +571,8 @@ class RNFishjamClient(
   fun toggleScreenShareTrackEncoding(encoding: String): Map<String, Any> {
     ensureScreenShareTrack()
     getLocalScreenShareTrack()?.let {
-      screenShareSimulcastConfig = toggleTrackEncoding(encoding, it.id(), screenShareSimulcastConfig)
+      screenShareSimulcastConfig =
+        toggleTrackEncoding(encoding, it.id(), screenShareSimulcastConfig)
     }
     return getSimulcastConfigAsRNMap(screenShareSimulcastConfig)
   }
@@ -743,10 +766,12 @@ class RNFishjamClient(
     event: EmitableEvents,
     data: Map<String, Any?> = mapOf()
   ) {
-    sendEvent(event.name, data)
+    CoroutineScope(Dispatchers.Main).launch {
+      sendEvent(event.name, data)
+    }
   }
 
-  private fun emitWarning(warning: String) {
+  fun emitWarning(warning: String) {
     emitEvent(EmitableEvents.Warning, mapOf("message" to warning))
   }
 
@@ -822,7 +847,7 @@ class RNFishjamClient(
 
   private fun addOrUpdateTrack(track: Track) {
     emitEndpoints()
-    onTracksUpdateListeners.forEach { it.onTracksUpdate() }
+    trackUpdateListenersManager.notifyListeners()
   }
 
   override fun onTrackReady(track: Track) {

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,24 +93,32 @@ class ForegroundServiceConfig : Record {
 
   @Field
   val notificationTitle: String? = null
+}
+
+class ForegroundServicePermissionsConfig : Record {
+  @Field
+  val enableCamera: Boolean = false
+
+  @Field
+  val enableMicrophone: Boolean = false
 
   @Field
-  val foregroundServiceTypes: IntArray = intArrayOf()
+  val enableScreenSharing: Boolean = false
 }
 
 class RNFishjamClientModule : Module() {
   override fun definition() =
     ModuleDefinition {
-      Name("RNFishjamClient")
-
-      Events(EmitableEvents.allEvents)
+      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)
@@ -131,6 +136,26 @@ 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, peerToken: String, peerMetadata: Map<String, Any>, config: ConnectConfig, promise: Promise ->
@@ -151,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()
@@ -199,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()
@@ -299,64 +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")
-        }
-
-        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("configureForegroundService") { config: ForegroundServiceNotificationConfig ->
+        return@Function rnFishjamClient.configureForegroundService(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)
+      AsyncFunction("startForegroundService") Coroutine { config: ForegroundServicePermissionsConfig ->
+        rnFishjamClient.startForegroundService(config)
       }
 
-      Property("peerStatus") {
-        return@Property rnFishjamClient.peerStatus
+      Function("stopForegroundService") {
+        rnFishjamClient.stopForegroundService()
       }
     }
 }

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

@@ -4,12 +4,13 @@ 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),
-  RNFishjamClient.OnLocalCameraTrackChangedListener {
+  LocalCameraTrackChangedListener {
   private var localVideoTrack: LocalVideoTrack? = null
 
   private fun trySetLocalCameraTrack() {
@@ -31,13 +32,13 @@ class VideoPreviewView(
   }
 
   override fun onDetachedFromWindow() {
-    RNFishjamClient.localCameraTrackListeners.remove(this)
+    RNFishjamClient.localCameraTracksChangedListenersManager.remove(this)
     super.onDetachedFromWindow()
     dispose()
   }
 
   override fun onAttachedToWindow() {
-    RNFishjamClient.localCameraTrackListeners.add(this)
+    RNFishjamClient.localCameraTracksChangedListenersManager.add(this)
     super.onAttachedToWindow()
     initialize()
   }

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")