Rename membrane webrtc -> fishjam client

Author: graszka22

android/src/main/java/org/membraneframework/reactnative/MembraneWebRTC.kt android/src/main/java/org/membraneframework/reactnative/RNFishjamClient.kt

@@ -34,7 +34,7 @@ import org.membraneframework.rtc.utils.Metadata
 import org.webrtc.Logging
 import java.util.UUID
 
-class MembraneWebRTC(val sendEvent: (name: String, data: Map<String, Any?>) -> Unit) :
+class RNFishjamClient(val sendEvent: (name: String, data: Map<String, Any?>) -> Unit) :
   FishjamClientListener {
   private val SCREENCAST_REQUEST = 1
   private var fishjamClient: FishjamClient? = null
@@ -80,7 +80,7 @@ class MembraneWebRTC(val sendEvent: (name: String, data: Map<String, Any?>) -> U
     var onTracksUpdateListeners: MutableList<OnTrackUpdateListener> = mutableListOf()
   }
 
-  fun onModuleCreate(appContext: AppContext){
+  fun onModuleCreate(appContext: AppContext) {
     this.appContext = appContext
     this.audioSwitchManager = AudioSwitchManager(appContext.reactContext!!)
   }
@@ -855,6 +855,4 @@ class MembraneWebRTC(val sendEvent: (name: String, data: Map<String, Any?>) -> U
   }
 
   override fun onDisconnected() {}
-
-
 }

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

@@ -71,9 +71,9 @@ class ScreencastOptions : Record {
   val maxBandwidthInt: Int = 0
 }
 
-class MembraneWebRTCModule : Module() {
+class RNFishjamClientModule : Module() {
   override fun definition() = ModuleDefinition {
-    Name("MembraneWebRTC")
+    Name("RNFishjamClient")
 
     Events(
       "IsCameraOn",
@@ -86,204 +86,204 @@ class MembraneWebRTCModule : Module() {
       "BandwidthEstimation"
     )
 
-    val membraneWebRTC = MembraneWebRTC { name: String, data: Map<String, Any?> ->
+    val rnFishjamClient = RNFishjamClient { name: String, data: Map<String, Any?> ->
       sendEvent(name, data)
     }
 
     OnCreate {
-      membraneWebRTC.onModuleCreate(appContext)
+      rnFishjamClient.onModuleCreate(appContext)
     }
 
     OnDestroy {
-      membraneWebRTC.onModuleDestroy()
+      rnFishjamClient.onModuleDestroy()
     }
 
     OnActivityDestroys {
-      membraneWebRTC.cleanUp()
+      rnFishjamClient.cleanUp()
     }
 
     OnActivityResult { _, result ->
-      membraneWebRTC.onActivityResult(result.requestCode, result.resultCode, result.data)
+      rnFishjamClient.onActivityResult(result.requestCode, result.resultCode, result.data)
     }
 
     AsyncFunction("connect") { url: String, peerToken: String, promise: Promise ->
       CoroutineScope(Dispatchers.Main).launch {
-        membraneWebRTC.create()
-        membraneWebRTC.connect(url, peerToken, promise)
+        rnFishjamClient.create()
+        rnFishjamClient.connect(url, peerToken, promise)
       }
     }
 
     AsyncFunction("joinRoom") { peerMetadata: Map<String, Any>, promise: Promise ->
       CoroutineScope(Dispatchers.Main).launch {
-        membraneWebRTC.joinRoom(peerMetadata, promise)
+        rnFishjamClient.joinRoom(peerMetadata, promise)
       }
     }
 
-    AsyncFunction("leaveRoom") {  ->
+    AsyncFunction("leaveRoom") { ->
       CoroutineScope(Dispatchers.Main).launch {
-        membraneWebRTC.leaveRoom()
+        rnFishjamClient.leaveRoom()
       }
     }
 
     AsyncFunction("cleanUp") Coroutine { ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.cleanUp()
+        rnFishjamClient.cleanUp()
       }
     }
 
 
     AsyncFunction("startCamera") Coroutine { config: CameraConfig ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.startCamera(config)
+        rnFishjamClient.startCamera(config)
       }
     }
 
     AsyncFunction("startMicrophone") Coroutine { config: MicrophoneConfig ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.startMicrophone(config)
+        rnFishjamClient.startMicrophone(config)
       }
     }
 
     Property("isMicrophoneOn") {
-      return@Property membraneWebRTC.isMicrophoneOn
+      return@Property rnFishjamClient.isMicrophoneOn
     }
 
     AsyncFunction("toggleMicrophone") Coroutine { ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.toggleMicrophone()
+        rnFishjamClient.toggleMicrophone()
       }
     }
 
     Property("isCameraOn") {
-      return@Property membraneWebRTC.isCameraOn
+      return@Property rnFishjamClient.isCameraOn
     }
 
     AsyncFunction("toggleCamera") Coroutine { ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.toggleCamera()
+        rnFishjamClient.toggleCamera()
       }
     }
 
     AsyncFunction("flipCamera") Coroutine { ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.flipCamera()
+        rnFishjamClient.flipCamera()
       }
     }
 
     AsyncFunction("switchCamera") Coroutine { captureDeviceId: String ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.switchCamera(captureDeviceId)
+        rnFishjamClient.switchCamera(captureDeviceId)
       }
     }
 
     AsyncFunction("getCaptureDevices") Coroutine { ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.getCaptureDevices()
+        rnFishjamClient.getCaptureDevices()
       }
     }
 
     AsyncFunction("toggleScreencast") { screencastOptions: ScreencastOptions, promise: Promise ->
       CoroutineScope(Dispatchers.Main).launch {
-        membraneWebRTC.toggleScreencast(screencastOptions, promise)
+        rnFishjamClient.toggleScreencast(screencastOptions, promise)
       }
     }
 
     Property("isScreencastOn") {
-      return@Property membraneWebRTC.isScreencastOn
+      return@Property rnFishjamClient.isScreencastOn
     }
 
     AsyncFunction("getEndpoints") Coroutine { ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.getEndpoints()
+        rnFishjamClient.getEndpoints()
       }
     }
 
     AsyncFunction("updateEndpointMetadata") Coroutine { metadata: Map<String, Any> ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.updateEndpointMetadata(metadata)
+        rnFishjamClient.updateEndpointMetadata(metadata)
       }
     }
 
     AsyncFunction("updateVideoTrackMetadata") Coroutine { metadata: Map<String, Any> ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.updateLocalVideoTrackMetadata(metadata)
+        rnFishjamClient.updateLocalVideoTrackMetadata(metadata)
       }
     }
 
     AsyncFunction("updateAudioTrackMetadata") Coroutine { metadata: Map<String, Any> ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.updateLocalAudioTrackMetadata(metadata)
+        rnFishjamClient.updateLocalAudioTrackMetadata(metadata)
       }
     }
 
     AsyncFunction("updateScreencastTrackMetadata") Coroutine { metadata: Map<String, Any> ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.updateLocalScreencastTrackMetadata(metadata)
+        rnFishjamClient.updateLocalScreencastTrackMetadata(metadata)
       }
     }
 
     AsyncFunction("setOutputAudioDevice") { audioDevice: String ->
-      membraneWebRTC.setOutputAudioDevice(audioDevice)
+      rnFishjamClient.setOutputAudioDevice(audioDevice)
     }
 
     AsyncFunction("startAudioSwitcher") {
-      membraneWebRTC.startAudioSwitcher()
+      rnFishjamClient.startAudioSwitcher()
     }
 
     AsyncFunction("stopAudioSwitcher") {
-      membraneWebRTC.stopAudioSwitcher()
+      rnFishjamClient.stopAudioSwitcher()
     }
 
     AsyncFunction("toggleScreencastTrackEncoding") Coroutine { encoding: String ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.toggleScreencastTrackEncoding(encoding)
+        rnFishjamClient.toggleScreencastTrackEncoding(encoding)
       }
     }
 
     AsyncFunction("setScreencastTrackBandwidth") Coroutine { bandwidth: Int ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.setScreencastTrackBandwidth(bandwidth)
+        rnFishjamClient.setScreencastTrackBandwidth(bandwidth)
       }
     }
 
     AsyncFunction("setScreencastTrackEncodingBandwidth") Coroutine { encoding: String, bandwidth: Int ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.setScreencastTrackEncodingBandwidth(encoding, bandwidth)
+        rnFishjamClient.setScreencastTrackEncodingBandwidth(encoding, bandwidth)
       }
     }
 
     AsyncFunction("setTargetTrackEncoding") Coroutine { trackId: String, encoding: String ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.setTargetTrackEncoding(trackId, encoding)
+        rnFishjamClient.setTargetTrackEncoding(trackId, encoding)
       }
     }
 
     AsyncFunction("toggleVideoTrackEncoding") Coroutine { encoding: String ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.toggleVideoTrackEncoding(encoding)
+        rnFishjamClient.toggleVideoTrackEncoding(encoding)
       }
     }
 
     AsyncFunction("setVideoTrackEncodingBandwidth") Coroutine { encoding: String, bandwidth: Int ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.setVideoTrackEncodingBandwidth(encoding, bandwidth)
+        rnFishjamClient.setVideoTrackEncodingBandwidth(encoding, bandwidth)
       }
     }
 
     AsyncFunction("setVideoTrackBandwidth") Coroutine { bandwidth: Int ->
       withContext(Dispatchers.Main) {
-        membraneWebRTC.setVideoTrackBandwidth(bandwidth)
+        rnFishjamClient.setVideoTrackBandwidth(bandwidth)
       }
     }
 
     AsyncFunction("changeWebRTCLoggingSeverity") Coroutine { severity: String ->
       CoroutineScope(Dispatchers.Main).launch {
-        membraneWebRTC.changeWebRTCLoggingSeverity(severity)
+        rnFishjamClient.changeWebRTCLoggingSeverity(severity)
       }
     }
 
     AsyncFunction("getStatistics") { ->
-      membraneWebRTC.getStatistics()
+      rnFishjamClient.getStatistics()
     }
   }
 }

android/src/main/java/org/membraneframework/reactnative/VideoRendererView.kt

@@ -11,14 +11,14 @@ import org.membraneframework.rtc.ui.VideoTextureViewRenderer
 import org.webrtc.RendererCommon
 
 class VideoRendererView(context: Context, appContext: AppContext) : ExpoView(context, appContext),
-    MembraneWebRTC.OnTrackUpdateListener {
+    RNFishjamClient.OnTrackUpdateListener {
     var isInitialized = false
     var activeVideoTrack: VideoTrack? = null
     var trackId: String? = null
 
     private val videoView = VideoTextureViewRenderer(context).also {
         addView(it)
-        MembraneWebRTC.onTracksUpdateListeners.add(this)
+        RNFishjamClient.onTracksUpdateListeners.add(this)
     }
 
     private fun setupTrack(videoTrack: VideoTrack) {
@@ -31,7 +31,7 @@ class VideoRendererView(context: Context, appContext: AppContext) : ExpoView(con
 
     private fun update() {
         CoroutineScope(Dispatchers.Main).launch {
-            val endpoint = MembraneWebRTC.endpoints.values.firstOrNull { it.videoTracks[trackId] != null }
+            val endpoint = RNFishjamClient.endpoints.values.firstOrNull { it.videoTracks[trackId] != null }
             val videoTrack = endpoint?.videoTracks?.get(trackId) ?: return@launch
             if(!isInitialized) {
                 isInitialized = true
@@ -49,7 +49,7 @@ class VideoRendererView(context: Context, appContext: AppContext) : ExpoView(con
     fun dispose() {
         activeVideoTrack?.removeRenderer(videoView)
         videoView.release()
-        MembraneWebRTC.onTracksUpdateListeners.remove(this)
+        RNFishjamClient.onTracksUpdateListeners.remove(this)
     }
 
     override fun onTracksUpdate() {
@@ -70,4 +70,4 @@ class VideoRendererView(context: Context, appContext: AppContext) : ExpoView(con
         videoView.setMirror(mirrorVideo)
     }
 
-}
+}