@fishjam-cloud/react-native-client 0.24.0 → 0.25.0-rc.1

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

@@ -1,257 +0,0 @@
-package io.fishjam.reactnative
-
-import android.animation.ValueAnimator
-import android.annotation.SuppressLint
-import android.content.Context
-import android.content.res.Resources
-import android.graphics.Color
-import android.graphics.Rect
-import android.graphics.drawable.ColorDrawable
-import android.os.Handler
-import android.os.Looper
-import android.view.animation.LinearInterpolator
-import androidx.core.view.ViewCompat
-import com.fishjamcloud.client.media.LocalVideoTrack
-import com.fishjamcloud.client.media.VideoTrack
-import com.fishjamcloud.client.models.Dimensions
-import com.fishjamcloud.client.ui.VideoSurfaceViewRenderer
-import com.fishjamcloud.client.ui.VideoSurfaceViewRendererListener
-import expo.modules.kotlin.AppContext
-import expo.modules.kotlin.views.ExpoView
-import io.fishjam.reactnative.managers.LocalTrackSwitchListener
-import kotlinx.coroutines.delay
-import org.webrtc.RendererCommon
-
-abstract class VideoView(
-  context: Context,
-  appContext: AppContext
-) : ExpoView(context, appContext),
-  LocalTrackSwitchListener, VideoSurfaceViewRendererListener {
-  protected val videoView: VideoSurfaceViewRenderer = RNFishjamClient.fishjamClient.createVideoViewRenderer().also {
-    it.setEnableHardwareScaler(true)
-    addView(it)
-  }
-
-  private var frameHeight: Int = 0
-  private var frameWidth: Int = 0
-
-  private var scalingType = RendererCommon.ScalingType.SCALE_ASPECT_FIT
-    set(value) {
-      field = value
-      videoView.setScalingType(scalingType)
-      post(requestSurfaceViewRendererLayoutRunnable)
-    }
-
-
-  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)
-      }
-    }
-
-  private val checkVisibilityHandler: Handler = Handler(Looper.getMainLooper())
-
-  // If set to `null` the view will always be rendered
-  var checkVisibilityDelayMillis: Long? = null
-    set(value) {
-      field = value
-      if (value == null) {
-        getVideoTrack()?.shouldReceive(true)
-      } else {
-        checkVisibilityHandler.post(checkVisibility)
-      }
-    }
-
-  private val checkVisibility =
-    object : Runnable {
-      override fun run() {
-        checkVisibilityDelayMillis?.let {
-          getVideoTrack()?.shouldReceive(isVisibleOnScreen)
-          checkVisibilityHandler.postDelayed(this, it)
-        }
-      }
-    }
-
-  private val isVisibleOnScreen: Boolean
-    get() {
-      if (!isShown) {
-        return false
-      }
-
-      val globalVisibleRect = Rect()
-      getGlobalVisibleRect(globalVisibleRect)
-      val displayMetrics = Resources.getSystem().displayMetrics
-      val screen = Rect(0, 0, displayMetrics.widthPixels, displayMetrics.heightPixels)
-      return screen.intersect(globalVisibleRect)
-    }
-
-  fun setVideoLayout(videoLayout: String) {
-    scalingType =
-      when (videoLayout) {
-        "FILL" -> RendererCommon.ScalingType.SCALE_ASPECT_FILL
-        "FIT" -> RendererCommon.ScalingType.SCALE_ASPECT_FIT
-        else -> RendererCommon.ScalingType.SCALE_ASPECT_FILL
-      }
-  }
-
-  val dimensionsListener = object : VideoSurfaceViewRendererListener {
-    override fun onDimensionsChanged(dimensions: Dimensions) {
-      if (dimensions.height == frameHeight && dimensions.width == frameWidth) {
-        return
-      }
-      frameWidth = dimensions.width
-      frameHeight = dimensions.height
-
-      post(requestSurfaceViewRendererLayoutRunnable);
-    }
-  }
-
-  init {
-    RNFishjamClient.localTracksSwitchListenerManager.add(this)
-    videoView.addDimensionsListener(dimensionsListener)
-  }
-
-  open fun dispose() {
-    checkVisibilityHandler.removeCallbacksAndMessages(null)
-    videoView.removeDimensionsListener(dimensionsListener)
-    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()
-    }
-  }
-
-  private val requestSurfaceViewRendererLayoutRunnable: Runnable = object : Runnable {
-    override fun run() {
-      requestSurfaceViewRendererLayout()
-    }
-  }
-
-  /**
-   * Inspired by:
-   * https://github.com/react-native-webrtc/react-native-webrtc/blob/5ecc86111c2f8e0d152d719f8b7b357a601150b6/android/src/main/java/com/oney/WebRTCModule/WebRTCView.java#L292
-   */
-  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
-    super.onLayout(changed, l, t, r, b)
-
-    var left = l
-    var top = t
-    var right = r
-    var bottom = b
-
-    val height = b - t
-    val width = r - l
-
-    if (height == 0 || width == 0) {
-      left = 0
-      top = 0
-      right = 0
-      bottom = 0
-    } else {
-      when (scalingType) {
-        RendererCommon.ScalingType.SCALE_ASPECT_FILL -> {
-          // Fill this ViewGroup with videoView and the latter
-          // will take care of filling itself with the video similarly to
-          // the cover value the CSS property object-fit.
-          left = 0
-          top = 0
-          right = width
-          bottom = height
-        }
-        RendererCommon.ScalingType.SCALE_ASPECT_FIT -> {
-          // Lay videoView out inside this ViewGroup in accord
-          // with the contain value of the CSS property object-fit.
-          // VideoView will fill itself with the video similarly
-          // to the cover or contain value of the CSS property object-fit
-          // (which will not matter, eventually).
-          if (frameHeight == 0 || frameWidth == 0) {
-            // If frame dimensions are not yet available, fill the container
-            // to ensure the view is visible. It will re-layout once dimensions arrive.
-            left = 0
-            top = 0
-            right = width
-            bottom = height
-          } else {
-            val frameAspectRatio = frameWidth.toFloat() / frameHeight.toFloat()
-            val frameDisplaySize = RendererCommon.getDisplaySize(
-              scalingType,
-              frameAspectRatio,
-              width,
-              height
-            )
-
-            left = (width - frameDisplaySize.x) / 2
-            top = (height - frameDisplaySize.y) / 2
-            right = left + frameDisplaySize.x
-            bottom = top + frameDisplaySize.y
-          }
-        }
-        else -> {
-          // Default to SCALE_ASPECT_FIT behavior
-          if (frameHeight == 0 || frameWidth == 0) {
-            // If frame dimensions are not yet available, fill the container
-            // to ensure the view is visible. It will re-layout once dimensions arrive.
-            left = 0
-            top = 0
-            right = width
-            bottom = height
-          } else {
-            val frameAspectRatio = frameWidth.toFloat() / frameHeight.toFloat()
-            val frameDisplaySize = RendererCommon.getDisplaySize(
-              scalingType,
-              frameAspectRatio,
-              width,
-              height
-            )
-
-            left = (width - frameDisplaySize.x) / 2
-            top = (height - frameDisplaySize.y) / 2
-            right = left + frameDisplaySize.x
-            bottom = top + frameDisplaySize.y
-          }
-        }
-      }
-    }
-
-    videoView.layout(left, top, right, bottom)
-  }
-
-  /**
-   * Inspired by:
-   * https://github.com/react-native-webrtc/react-native-webrtc/blob/5ecc86111c2f8e0d152d719f8b7b357a601150b6/android/src/main/java/com/oney/WebRTCModule/WebRTCView.java#L386
-   */
-  @SuppressLint("WrongCall")
-  public fun requestSurfaceViewRendererLayout() {
-    // Google/WebRTC just call requestLayout() on surfaceViewRenderer when
-    // they change the value of its mirror or surfaceType property.
-    videoView.requestLayout()
-    // The above is not enough though when the video frame's dimensions or
-    // rotation change. The following will suffice.
-    if (!ViewCompat.isInLayout(this)) {
-      onLayout( /* changed */
-        false, left, top, right, bottom
-      )
-    }
-  }
-
-  fun setupTrack() {
-    videoView.setMirror((getVideoTrack() as? LocalVideoTrack)?.isFrontCamera() ?: false)
-    checkVisibilityHandler.post(checkVisibility)
-  }
-}

package/android/src/main/java/io/fishjam/reactnative/extensions/CaptureDevice.kt

@@ -1,17 +0,0 @@
-package io.fishjam.reactnative.extensions
-
-import com.fishjamcloud.client.media.CaptureDevice
-
-typealias LocalCamera = Map<String, Any>
-
-fun CaptureDevice.toLocalCamera(): LocalCamera =
-  mapOf<String, Any>(
-    "id" to deviceName,
-    "name" to deviceName,
-    "facingDirection" to
-      when (true) {
-        isFrontFacing -> "front"
-        isBackFacing -> "back"
-        else -> "unspecified"
-      }
-  )

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

@@ -1,101 +0,0 @@
-package io.fishjam.reactnative.foregroundService
-
-import android.app.Notification
-import android.app.NotificationChannel
-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
-
-class FishjamForegroundService : Service() {
-  companion object {
-    private const val FOREGROUND_SERVICE_ID = 1668
-  }
-
-  private val binder = LocalBinder()
-
-  inner class LocalBinder : Binder() {
-    fun getService(): FishjamForegroundService = this@FishjamForegroundService
-  }
-
-  override fun onBind(intent: Intent): IBinder = binder
-
-  override fun onStartCommand(
-    intent: Intent?,
-    flags: Int,
-    startId: Int
-  ): Int {
-    restartService(intent)
-    return START_NOT_STICKY
-  }
-
-  fun restartService(intent: Intent?) {
-    val channelId = intent!!.getStringExtra("channelId")!!
-    val channelName = intent.getStringExtra("channelName")!!
-    val notificationTitle = intent.getStringExtra("notificationTitle")!!
-    val notificationContent = intent.getStringExtra("notificationContent")!!
-    val foregroundServiceTypesArray = intent.getIntArrayExtra("foregroundServiceTypes")!!
-    // Create "bitwise or" of foregroundServiceTypesArray
-    val foregroundServiceType = foregroundServiceTypesArray.reduce { acc, value -> acc or value }
-
-    val pendingIntent =
-      PendingIntent.getActivity(
-        this,
-        0,
-        intent,
-        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
-      )
-
-    val notification: Notification =
-      NotificationCompat
-        .Builder(this, channelId)
-        .setContentTitle(notificationTitle)
-        .setContentText(notificationContent)
-        .setContentIntent(pendingIntent)
-        .setSmallIcon(android.R.drawable.ic_dialog_info)
-        .build()
-
-    createNotificationChannel(channelId, channelName)
-    startForegroundWithNotification(notification, foregroundServiceType)
-  }
-
-  private fun startForegroundWithNotification(
-    notification: Notification,
-    foregroundServiceType: Int
-  ) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-      startForeground(
-        FOREGROUND_SERVICE_ID,
-        notification,
-        foregroundServiceType
-      )
-    } else {
-      startForeground(
-        FOREGROUND_SERVICE_ID,
-        notification
-      )
-    }
-  }
-
-  private fun createNotificationChannel(
-    channelId: String,
-    channelName: String
-  ) {
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-      return
-    }
-
-    val serviceChannel =
-      NotificationChannel(
-        channelId,
-        channelName,
-        NotificationManager.IMPORTANCE_HIGH
-      )
-    val notificationManager = getSystemService(NOTIFICATION_SERVICE) as? NotificationManager
-    notificationManager?.createNotificationChannel(serviceChannel)
-  }
-}

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

@@ -1,118 +0,0 @@
-package io.fishjam.reactnative.foregroundService
-
-import android.content.ComponentName
-import android.content.Context
-import android.content.Intent
-import android.content.ServiceConnection
-import android.os.Build
-import android.os.IBinder
-import expo.modules.kotlin.AppContext
-import expo.modules.kotlin.exception.CodedException
-import io.fishjam.reactnative.ForegroundServiceConfig
-import kotlinx.coroutines.CancellableContinuation
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
-
-class ForegroundServiceManager(
-  private val appContext: AppContext
-) {
-  private val reactContext by lazy {
-    appContext.reactContext ?: throw CodedException("reactContext not found")
-  }
-
-  private var serviceState = ForegroundServiceState()
-  private var serviceInstance: FishjamForegroundService? = null
-  private var serviceConnectedContinuation: CancellableContinuation<Unit>? = null
-  private val serviceIntent =
-    Intent(
-      appContext.reactContext,
-      FishjamForegroundService::class.java
-    )
-
-  private val connection =
-    object : ServiceConnection {
-      override fun onServiceConnected(
-        className: ComponentName,
-        service: IBinder
-      ) {
-        serviceInstance = (service as FishjamForegroundService.LocalBinder).getService()
-        serviceConnectedContinuation?.resume(Unit)
-        serviceConnectedContinuation = null
-      }
-
-      override fun onServiceDisconnected(arg0: ComponentName) {
-        serviceInstance = null
-        serviceConnectedContinuation?.cancel()
-        serviceConnectedContinuation = null
-      }
-    }
-
-  fun updateServiceWithConfig(configUpdate: ForegroundServiceConfig) {
-    configUpdate.enableCamera?.let { serviceState.cameraEnabled = it }
-    configUpdate.enableMicrophone?.let { serviceState.microphoneEnabled = it }
-    configUpdate.channelId?.let { serviceState.channelId = it }
-    configUpdate.channelName?.let { serviceState.channelName = it }
-    configUpdate.notificationContent?.let { serviceState.notificationContent = it }
-    configUpdate.notificationTitle?.let { serviceState.notificationTitle = it }
-  }
-
-  fun updateService(update: ForegroundServiceState.() -> Unit) {
-    serviceState.update()
-  }
-
-  suspend fun start() {
-    val foregroundServiceTypes = serviceState.buildForegroundServiceTypes(appContext)
-
-    if (foregroundServiceTypes.isEmpty()) {
-      stop()
-      return
-    }
-
-    serviceIntent.apply {
-      putExtra("channelId", serviceState.channelId)
-      putExtra("channelName", serviceState.channelName)
-      putExtra("notificationContent", serviceState.notificationContent)
-      putExtra("notificationTitle", serviceState.notificationTitle)
-      putExtra("foregroundServiceTypes", foregroundServiceTypes.toIntArray())
-    }
-
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      reactContext.startForegroundService(serviceIntent)
-    } else {
-      reactContext.startService(serviceIntent)
-    }
-
-    bindServiceIfNeededAndAwait()
-  }
-
-  fun stop() {
-    if (serviceInstance != null) {
-      appContext.currentActivity?.unbindService(connection)
-        ?: throw CodedException("Current activity not found")
-      serviceInstance = null
-    }
-    reactContext.stopService(serviceIntent)
-    serviceConnectedContinuation?.cancel()
-    serviceConnectedContinuation = null
-  }
-
-  private suspend fun bindServiceIfNeededAndAwait() =
-    suspendCancellableCoroutine { continuation ->
-      if (serviceInstance == null) {
-        serviceConnectedContinuation = continuation
-        runCatching {
-          appContext.currentActivity?.bindService(
-            serviceIntent,
-            connection,
-            Context.BIND_AUTO_CREATE
-          )
-        }.onFailure { error ->
-          continuation.cancel(CodedException("Failed to bind service: ${error.message}"))
-        }
-      } else {
-        serviceInstance?.restartService(serviceIntent)
-        continuation.resume(Unit)
-        serviceConnectedContinuation = null
-      }
-    }
-}

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

@@ -1,46 +0,0 @@
-package io.fishjam.reactnative.foregroundService
-
-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 expo.modules.kotlin.AppContext
-import expo.modules.kotlin.exception.CodedException
-import io.fishjam.reactnative.utils.PermissionUtils
-
-data class ForegroundServiceState(
-  var cameraEnabled: Boolean = false,
-  var microphoneEnabled: Boolean = false,
-  var screenSharingEnabled: Boolean = false,
-  var channelId: String = "com.fishjam.foregroundservice.channel",
-  var channelName: String = "Fishjam Notifications",
-  var notificationContent: String = "[PLACEHOLDER] Your video call is ongoing",
-  var notificationTitle: String = "[PLACEHOLDER] Tap to return to the call."
-) {
-  fun buildForegroundServiceTypes(appContext: AppContext): List<Int> =
-    buildList {
-      if (cameraEnabled) {
-        addIfPermissionGranted(
-          FOREGROUND_SERVICE_TYPE_CAMERA,
-          "camera"
-        ) { PermissionUtils.hasCameraPermission(appContext) }
-      }
-      if (microphoneEnabled) {
-        addIfPermissionGranted(
-          FOREGROUND_SERVICE_TYPE_MICROPHONE,
-          "microphone"
-        ) { PermissionUtils.hasMicrophonePermission(appContext) }
-      }
-      if (screenSharingEnabled) add(FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION)
-    }
-
-  private fun MutableList<Int>.addIfPermissionGranted(
-    serviceType: Int,
-    permissionName: String,
-    hasPermission: () -> Boolean
-  ) {
-    if (!hasPermission()) {
-      throw CodedException("Cannot start a $permissionName foreground service without $permissionName permission.")
-    }
-    add(serviceType)
-  }
-}

package/android/src/main/java/io/fishjam/reactnative/helpers/PictureInPictureHelperFragment.kt

@@ -1,20 +0,0 @@
-package io.fishjam.reactnative.helpers
-
-import androidx.fragment.app.Fragment
-import io.fishjam.reactnative.PipContainerView
-import java.util.UUID
-
-class PictureInPictureHelperFragment(private val containerView: PipContainerView) : Fragment() {
-  val id = "${PictureInPictureHelperFragment::class.java.simpleName}_${UUID.randomUUID()}"
-
-  override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
-    super.onPictureInPictureModeChanged(isInPictureInPictureMode)
-
-    if (isInPictureInPictureMode) {
-      containerView.layoutForPiPEnter()
-    } else {
-      containerView.layoutForPiPExit()
-    }
-  }
-}
-

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

@@ -1,24 +0,0 @@
-package io.fishjam.reactnative.managers
-
-import java.util.concurrent.CopyOnWriteArrayList
-
-abstract class ListenerManager<T> {
-  protected var listeners = CopyOnWriteArrayList<T>()
-    private set
-
-  fun add(listener: T) {
-    listeners.add(listener)
-  }
-
-  fun remove(listener: T) {
-    listeners.remove(listener)
-  }
-}
-
-open class SingleListenerManager<T>(
-  private val notify: (T) -> Unit
-) : ListenerManager<T>() {
-  fun notifyListeners() {
-    for (listener in listeners) notify(listener)
-  }
-}

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

@@ -1,8 +0,0 @@
-package io.fishjam.reactnative.managers
-
-interface LocalCameraTrackChangedListener {
-  fun onLocalCameraTrackChanged()
-}
-
-class LocalCameraTracksChangedListenersManager :
-  SingleListenerManager<LocalCameraTrackChangedListener>(LocalCameraTrackChangedListener::onLocalCameraTrackChanged)

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

@@ -1,17 +0,0 @@
-package io.fishjam.reactnative.managers
-
-interface LocalTrackSwitchListener {
-  suspend fun onLocalTrackWillSwitch()
-
-  suspend fun onLocalTrackSwitched()
-}
-
-class LocalTracksSwitchListenersManager : ListenerManager<LocalTrackSwitchListener>() {
-  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

@@ -1,7 +0,0 @@
-package io.fishjam.reactnative.managers
-
-interface TrackUpdateListener {
-  fun onTracksUpdate()
-}
-
-class TracksUpdateListenersManager : SingleListenerManager<TrackUpdateListener>(TrackUpdateListener::onTracksUpdate)

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

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