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

package/ios/RNFishjamClient.swift

@@ -11,6 +11,7 @@ class RNFishjamClient: FishjamClientListener {
     var isMicrophoneOn = false
     var isCameraOn = false
     var isScreenShareOn = false
+    var isAppScreenShareOn = false
     var isConnected = false
 
     private var isCameraInitialized = false
@@ -28,9 +29,17 @@ class RNFishjamClient: FishjamClientListener {
     var audioSessionMode: AVAudioSession.Mode = AVAudioSession.Mode.videoChat
     var errorMessage: String?
 
+    private(set) var peerStatus: PeerStatus = .idle {
+        didSet {
+            let event = EmitableEvents.PeerStatusChanged
+            emit(event: event, data: [event.name: peerStatus.rawValue])
+        }
+    }
+
     let sendEvent: (_ eventName: String, _ data: [String: Any]) -> Void
 
-    static var onTracksUpdateListeners: [OnTrackUpdateListener] = []
+    static var tracksUpdateListenersManager = TracksUpdateListenersManager()
+    static var localCameraTracksChangedListenersManager = LocalCameraTracksChangedListenersManager()
 
     init(sendEvent: @escaping (_ eventName: String, _ data: [String: Any]) -> Void) {
         self.sendEvent = sendEvent
@@ -103,26 +112,34 @@ class RNFishjamClient: FishjamClientListener {
             }
         }()
         let videoParameters = VideoParameters(
-            dimensions: flipDimensions ? preset.dimensions.flip() : preset.dimensions,
+            dimensions: flipDimensions ? preset.dimensions.flipped : preset.dimensions,
             maxBandwidth: videoBandwidthLimit,
             simulcastConfig: simulcastConfig
         )
         return videoParameters
     }
 
-    private func getLocalVideoTrack() -> LocalVideoTrack? {
-        return RNFishjamClient.fishjamClient?.getLocalEndpoint().tracks.first { $0.value is LocalVideoTrack }?.value
-            as? LocalVideoTrack
+    private var localEndpoint: Endpoint? {
+        RNFishjamClient.fishjamClient?.getLocalEndpoint()
+    }
+
+    private func getLocalCameraTrack() -> LocalCameraTrack? {
+        return localEndpoint?.tracks.compactMap { $0.value as? LocalCameraTrack }.first
+
     }
 
     private func getLocalAudioTrack() -> LocalAudioTrack? {
-        return RNFishjamClient.fishjamClient?.getLocalEndpoint().tracks.first { $0.value is LocalAudioTrack }?.value
-            as? LocalAudioTrack
+        return localEndpoint?.tracks.compactMap { $0.value as? LocalAudioTrack }.first
+
     }
 
-    private func getLocalScreenShareTrack() -> LocalScreenShareTrack? {
-        return RNFishjamClient.fishjamClient?.getLocalEndpoint().tracks.first { $0.value is LocalScreenShareTrack }?
-            .value as? LocalScreenShareTrack
+    private func getLocalScreenBroadcastTrack() -> LocalBroadcastScreenShareTrack? {
+        return localEndpoint?.tracks.compactMap { $0.value as? LocalBroadcastScreenShareTrack }.first
+
+    }
+
+    private func getLocalScreenAppTrack() -> LocalAppScreenShareTrack? {
+        return localEndpoint?.tracks.compactMap { $0.value as? LocalAppScreenShareTrack }.first
     }
 
     private func ensureCreated() throws {
@@ -143,8 +160,8 @@ class RNFishjamClient: FishjamClientListener {
         }
     }
 
-    private func ensureVideoTrack() throws {
-        if getLocalVideoTrack() == nil {
+    private func ensureCameraTrack() throws {
+        if getLocalCameraTrack() == nil {
             throw Exception(
                 name: "E_NO_LOCAL_VIDEO_TRACK",
                 description: "No local video track. Make sure to call connect() first!")
@@ -159,11 +176,19 @@ class RNFishjamClient: FishjamClientListener {
         }
     }
 
-    private func ensureScreenShareTrack() throws {
-        if getLocalScreenShareTrack() == nil {
+    private func ensureScreenBroadcastTrack() throws {
+        if getLocalScreenBroadcastTrack() == nil {
+            throw Exception(
+                name: "E_NO_LOCAL_SCREENSHARE_TRACK",
+                description: "No local screen broadcast track. Make sure to toggle screen broadcast on first!")
+        }
+    }
+
+    private func ensureScreenAppTrack() throws {
+        if getLocalScreenAppTrack() == nil {
             throw Exception(
                 name: "E_NO_LOCAL_SCREENSHARE_TRACK",
-                description: "No local screen share track. Make sure to toggle screen share on first!")
+                description: "No local screen app track. Make sure to toggle screen app on first!")
         }
     }
 
@@ -172,18 +197,16 @@ class RNFishjamClient: FishjamClientListener {
             connectPromise.reject("E_MEMBRANE_CONNECT", "Failed to connect: socket error")
         }
         connectPromise = nil
-    }
-
-    func onAuthSuccess() {
-        join()
+        peerStatus = .error
     }
 
     func joinRoom(
-        url: String, participantToken: String, participantMetadata: [String: Any], config: ConnectConfig,
+        url: String, peerToken: String, peerMetadata: [String: Any], config: ConnectConfig,
         promise: Promise
     ) {
+        peerStatus = .connecting
         connectPromise = promise
-        localUserMetadata = participantMetadata.toMetadata()
+        localUserMetadata = ["server": [:], "peer": peerMetadata].toMetadata()
 
         let reconnectConfig = FishjamCloudClient.ReconnectConfig(
             maxAttempts: config.reconnectConfig.maxAttempts, initialDelayMs: config.reconnectConfig.initialDelayMs,
@@ -191,16 +214,12 @@ class RNFishjamClient: FishjamClientListener {
 
         RNFishjamClient.fishjamClient?.connect(
             config: FishjamCloudClient.ConnectConfig(
-                websocketUrl: url, token: participantToken, participantMetadata: .init(participantMetadata),
+                websocketUrl: url, token: peerToken, peerMetadata: localUserMetadata,
                 reconnectConfig: reconnectConfig
             ))
 
     }
 
-    func join() {
-        RNFishjamClient.fishjamClient?.join(peerMetadata: localUserMetadata)
-    }
-
     func leaveRoom() {
         if isScreenShareOn {
             let screenShareExtensionBundleId =
@@ -212,12 +231,15 @@ class RNFishjamClient: FishjamClientListener {
         isMicrophoneOn = false
         isCameraOn = false
         isScreenShareOn = false
+        isAppScreenShareOn = false
         isConnected = false
         isCameraInitialized = false
-        RNFishjamClient.fishjamClient?.leave()
+        RNFishjamClient.fishjamClient?.leave { [weak self] in
+            self?.emitEndpoints()
+        }
     }
 
-    func startCamera(config: CameraConfig) throws {
+    func startCamera(config: CameraConfig) async throws {
         try ensureCreated()
 
         guard !isCameraInitialized else {
@@ -225,13 +247,18 @@ class RNFishjamClient: FishjamClientListener {
             return
         }
 
+        guard await PermissionUtils.requestCameraPermission() else {
+            emit(warning: "Camera permission not granted.")
+            return
+        }
+
         let cameraTrack = try createCameraTrack(config: config)
         setCameraTrackState(cameraTrack, enabled: config.cameraEnabled)
         emitEndpoints()
         isCameraInitialized = true
     }
 
-    private func createCameraTrack(config: CameraConfig) throws -> LocalVideoTrack {
+    private func createCameraTrack(config: CameraConfig) throws -> LocalCameraTrack {
         try ensureCreated()
         let videoParameters = try getVideoParametersFromOptions(connectionOptions: config)
         videoSimulcastConfig = try getSimulcastConfigFromOptions(simulcastConfig: config.simulcastConfig)
@@ -242,43 +269,47 @@ class RNFishjamClient: FishjamClientListener {
         )
     }
 
-    private func setCameraTrackState(_ cameraTrack: LocalVideoTrack, enabled: Bool) {
+    private func setCameraTrackState(_ cameraTrack: LocalCameraTrack, enabled: Bool) {
         cameraTrack.enabled = enabled
         isCameraOn = enabled
-        let eventName = EmitableEvents.IsCameraOn
-        let isCameraEnabledMap = [eventName: enabled]
-        emitEvent(name: eventName, data: isCameraEnabledMap)
+        let event = EmitableEvents.IsCameraOn
+        let isCameraEnabledMap = [event.name: enabled]
+        emit(event: event, data: isCameraEnabledMap)
+        RNFishjamClient.localCameraTracksChangedListenersManager.notifyListeners()
     }
 
     func toggleCamera() throws -> Bool {
-        try ensureVideoTrack()
-        setCameraTrackState(getLocalVideoTrack()!, enabled: !isCameraOn)
+        try ensureCameraTrack()
+        setCameraTrackState(getLocalCameraTrack()!, enabled: !isCameraOn)
         return isCameraOn
     }
 
     func flipCamera() throws {
-        try ensureVideoTrack()
-        getLocalVideoTrack()?.flipCamera()
+        try ensureCameraTrack()
+        getLocalCameraTrack()?.flipCamera()
     }
 
     func switchCamera(cameraId: String) throws {
-        try ensureVideoTrack()
-        getLocalVideoTrack()?.switchCamera(deviceId: cameraId)
+        try ensureCameraTrack()
+        getLocalCameraTrack()?.switchCamera(deviceId: cameraId)
 
     }
 
-    func toggleMicrophone() throws -> Bool {
+    func toggleMicrophone() async throws -> Bool {
         if let audioTrack = getLocalAudioTrack() {
             setMicrophoneTrackState(audioTrack, enabled: !isMicrophoneOn)
         } else {
-            try startMicrophone()
+            try await startMicrophone()
         }
         return isMicrophoneOn
     }
 
-    func startMicrophone() throws {
-        let microphoneTrack = RNFishjamClient.fishjamClient!.createAudioTrack(
-            metadata: Metadata())
+    func startMicrophone() async throws {
+        guard await PermissionUtils.requestMicrophonePermission() else {
+            emit(warning: "Microphone permission not granted.")
+            return
+        }
+        let microphoneTrack = RNFishjamClient.fishjamClient!.createAudioTrack(metadata: Metadata())
         setAudioSessionMode()
         setMicrophoneTrackState(microphoneTrack, enabled: true)
         emitEndpoints()
@@ -287,10 +318,9 @@ class RNFishjamClient: FishjamClientListener {
     private func setMicrophoneTrackState(_ microphoneTrack: LocalAudioTrack, enabled: Bool) {
         microphoneTrack.enabled = enabled
         isMicrophoneOn = enabled
-        let eventName = EmitableEvents.IsMicrophoneOn
-        let isMicrophoneOnMap = [eventName: enabled]
-        print(isMicrophoneOnMap)
-        emitEvent(name: eventName, data: isMicrophoneOnMap)
+        let event = EmitableEvents.IsMicrophoneOn
+        let isMicrophoneOnMap = [event.name: enabled]
+        emit(event: event, data: isMicrophoneOnMap)
     }
 
     func setAudioSessionMode() {
@@ -314,6 +344,10 @@ class RNFishjamClient: FishjamClientListener {
     func toggleScreenShare(screenShareOptions: ScreenShareOptions) throws {
         try ensureCreated()
         try ensureConnected()
+        guard isAppScreenShareOn == false else {
+            emit(warning: "Screensharing screen not available during screensharing app.")
+            return
+        }
         guard let screenShareExtensionBundleId = Bundle.main.infoDictionary?["ScreenShareExtensionBundleId"] as? String
         else {
             throw Exception(
@@ -343,16 +377,20 @@ class RNFishjamClient: FishjamClientListener {
             maxBandwidth: screenShareOptions.maxBandwidth)
         let screenShareMetadata = screenShareOptions.screenShareMetadata.toMetadata()
         let videoParameters = getScreenShareVideoParameters(options: screenShareOptions)
-        RNFishjamClient.fishjamClient!.createScreenShareTrack(
+        RNFishjamClient.fishjamClient!.prepareForScreenBroadcast(
             appGroup: appGroupName,
             videoParameters: videoParameters,
             metadata: screenShareMetadata,
-            onStart: { [weak self] screenShareTrack in
-                guard let self = self else { return }
-
+            canStart: {
+                if self.isAppScreenShareOn {
+                    self.emit(warning: "Screensharing screen not available during screensharing app.")
+                }
+                return !self.isAppScreenShareOn
+            },
+            onStart: { [weak self] in
+                guard let self else { return }
                 do {
-                    //not sure should it be here, or outside or where?
-                    try setScreenShareTrackState(screenShareTrack, enabled: true)
+                    try setScreenShareTrackState(enabled: true)
                 } catch {
                     os_log(
                         "Error starting screen share: %{public}s", log: log, type: .error,
@@ -361,11 +399,10 @@ class RNFishjamClient: FishjamClientListener {
                 }
 
             },
-            onStop: { [weak self] screenShareTrack in
-                guard let self = self else { return }
+            onStop: { [weak self] in
+                guard let self else { return }
                 do {
-                    //not sure should it be here, or outside or where?
-                    try setScreenShareTrackState(screenShareTrack, enabled: false)
+                    try setScreenShareTrackState(enabled: false)
                 } catch {
                     os_log(
                         "Error stopping screen share: %{public}s", log: log, type: .error,
@@ -379,13 +416,55 @@ class RNFishjamClient: FishjamClientListener {
         }
     }
 
-    private func setScreenShareTrackState(_ screenShareTrack: LocalScreenShareTrack, enabled: Bool) throws {
-        //was not present before, test and maybe delete?
-        screenShareTrack.enabled = enabled
+    private func setScreenShareTrackState(enabled: Bool) throws {
         isScreenShareOn = enabled
-        let eventName = EmitableEvents.IsScreenShareOn
-        let isScreenShareEnabled = [eventName: enabled]
-        emitEvent(name: eventName, data: isScreenShareEnabled)
+        let event = EmitableEvents.IsScreenShareOn
+        let isScreenShareEnabled = [event.name: enabled]
+        emit(event: event, data: isScreenShareEnabled)
+    }
+
+    func startScreenAppShare(screenShareOptions: ScreenShareOptions) throws {
+        try ensureCreated()
+        try ensureConnected()
+
+        let simulcastConfig = try getSimulcastConfigFromOptions(simulcastConfig: screenShareOptions.simulcastConfig)
+
+        screenShareSimulcastConfig = simulcastConfig
+        screenShareMaxBandwidth = getMaxBandwidthFromOptions(maxBandwidth: screenShareOptions.maxBandwidth)
+        let metadata = screenShareOptions.screenShareMetadata.toMetadata()
+        let videoParameters = getScreenShareVideoParameters(options: screenShareOptions)
+        let screenAppTrack = RNFishjamClient.fishjamClient!.createScreenAppTrack(
+            videoParameters: videoParameters, metadata: metadata)
+        setScreenAppTrackState(screenAppTrack, enabled: true)
+        emitEndpoints()
+    }
+
+    func stopAppScreenShare() throws {
+        try ensureScreenAppTrack()
+        let track = getLocalScreenAppTrack()!
+        setScreenAppTrackState(track, enabled: false)
+        RNFishjamClient.fishjamClient?.removeTrack(trackId: track.id)
+        emitEndpoints()
+    }
+
+    func toggleAppScreenShare(screenShareOptions: ScreenShareOptions) throws {
+        guard isScreenShareOn == false else {
+            emit(warning: "App screensharing not available during screensharing.")
+            return
+        }
+        if getLocalScreenAppTrack() != nil {
+            try stopAppScreenShare()
+        } else {
+            try startScreenAppShare(screenShareOptions: screenShareOptions)
+        }
+    }
+
+    private func setScreenAppTrackState(_ track: LocalAppScreenShareTrack, enabled: Bool) {
+        track.enabled = enabled
+        isAppScreenShareOn = enabled
+        let event = EmitableEvents.IsAppScreenShareOn
+        let eventMap = [event.name: enabled]
+        emit(event: event, data: eventMap)
     }
 
     //returns local endpoint and remote endpoints
@@ -402,7 +481,7 @@ class RNFishjamClient: FishjamClientListener {
                 "id": endpoint.id,
                 "isLocal": endpoint.id == RNFishjamClient.fishjamClient!.getLocalEndpoint().id,
                 "type": endpoint.type,
-                "metadata": endpoint.metadata,
+                "metadata": endpoint.metadata.toDict(),
                 "tracks": endpoint.tracks.values.compactMap { track -> [String: Any?]? in
                     switch track {
                     case let track as RemoteVideoTrack:
@@ -422,14 +501,21 @@ class RNFishjamClient: FishjamClientListener {
                             "vadStatus": track.vadStatus.rawValue,
                         ]
 
-                    case let track as LocalVideoTrack:
+                    case let track as LocalCameraTrack:
                         return [
                             "id": track.id,
                             "type": "Video",
                             "metadata": track.metadata.toDict(),
                         ]
 
-                    case let track as LocalScreenShareTrack:
+                    case let track as LocalBroadcastScreenShareTrack:
+                        return [
+                            "id": track.id,
+                            "type": "Video",
+                            "metadata": track.metadata.toDict(),
+                        ]
+
+                    case let track as LocalAppScreenShareTrack:
                         return [
                             "id": track.id,
                             "type": "Video",
@@ -452,7 +538,7 @@ class RNFishjamClient: FishjamClientListener {
     }
 
     func getCaptureDevices() -> [[String: Any]] {
-        let devices = LocalVideoTrack.getCaptureDevices()
+        let devices = LocalCameraTrack.getCaptureDevices()
         return devices.map { device -> [String: Any] in
             let facingDirection =
                 switch device.position {
@@ -479,8 +565,8 @@ class RNFishjamClient: FishjamClientListener {
     }
 
     func updateLocalVideoTrackMetadata(metadata: [String: Any]) throws {
-        try ensureVideoTrack()
-        if let track = getLocalVideoTrack() {
+        try ensureCameraTrack()
+        if let track = getLocalCameraTrack() {
             updateTrackMetadata(trackId: track.id, metadata: metadata)
         }
     }
@@ -493,8 +579,8 @@ class RNFishjamClient: FishjamClientListener {
     }
 
     func updateLocalScreenShareTrackMetadata(metadata: [String: Any]) throws {
-        try ensureScreenShareTrack()
-        if let track = getLocalScreenShareTrack() {
+        try ensureScreenBroadcastTrack()
+        if let track = getLocalScreenBroadcastTrack() {
             updateTrackMetadata(trackId: track.id, metadata: metadata)
         }
     }
@@ -519,8 +605,8 @@ class RNFishjamClient: FishjamClientListener {
     }
 
     func toggleScreenShareTrackEncoding(encoding: String) throws -> [String: Any] {
-        try ensureScreenShareTrack()
-        if let track = getLocalScreenShareTrack() {
+        try ensureScreenBroadcastTrack()
+        if let track = getLocalScreenBroadcastTrack() {
             screenShareSimulcastConfig = try toggleTrackEncoding(
                 encoding: encoding, trackId: track.id, simulcastConfig: screenShareSimulcastConfig)
         }
@@ -528,15 +614,15 @@ class RNFishjamClient: FishjamClientListener {
     }
 
     func setScreenShareTrackBandwidth(bandwidth: Int) throws {
-        try ensureScreenShareTrack()
-        if let track = getLocalScreenShareTrack() {
+        try ensureScreenBroadcastTrack()
+        if let track = getLocalScreenBroadcastTrack() {
             RNFishjamClient.fishjamClient?.setTrackBandwidth(trackId: track.id, bandwidthLimit: bandwidth)
         }
     }
 
     func setScreenShareTrackEncodingBandwidth(encoding: String, bandwidth: Int) throws {
-        try ensureScreenShareTrack()
-        if let track = getLocalScreenShareTrack() {
+        try ensureScreenBroadcastTrack()
+        if let track = getLocalScreenBroadcastTrack() {
             RNFishjamClient.fishjamClient?.setEncodingBandwidth(
                 trackId: track.id, encoding: encoding, bandwidthLimit: bandwidth)
         }
@@ -549,30 +635,30 @@ class RNFishjamClient: FishjamClientListener {
     }
 
     func toggleVideoTrackEncoding(encoding: String) throws -> [String: Any] {
-        try ensureVideoTrack()
+        try ensureCameraTrack()
         try ensureConnected()
 
-        let track = getLocalVideoTrack()!
+        let track = getLocalCameraTrack()!
         videoSimulcastConfig = try toggleTrackEncoding(
             encoding: encoding, trackId: track.id, simulcastConfig: videoSimulcastConfig)
 
-        let eventName = EmitableEvents.SimulcastConfigUpdate
+        let event = EmitableEvents.SimulcastConfigUpdate
         let simulcastConfigAsRNMap = getSimulcastConfigAsRNMap(videoSimulcastConfig)
-        emitEvent(name: eventName, data: simulcastConfigAsRNMap)
+        emit(event: event, data: simulcastConfigAsRNMap)
 
         return simulcastConfigAsRNMap
     }
 
     func setVideoTrackEncodingBandwidth(encoding: String, bandwidth: Int) throws {
-        try ensureVideoTrack()
-        let track = getLocalVideoTrack()!
+        try ensureCameraTrack()
+        let track = getLocalCameraTrack()!
         RNFishjamClient.fishjamClient?.setEncodingBandwidth(
             trackId: track.id, encoding: encoding, bandwidthLimit: bandwidth)
     }
 
     func setVideoTrackBandwidth(bandwidth: Int) throws {
-        try ensureVideoTrack()
-        let track = getLocalVideoTrack()!
+        try ensureCameraTrack()
+        let track = getLocalCameraTrack()!
         RNFishjamClient.fishjamClient?.setTrackBandwidth(trackId: track.id, bandwidthLimit: bandwidth)
     }
 
@@ -666,25 +752,27 @@ class RNFishjamClient: FishjamClientListener {
             preset = VideoParameters.presetScreenShareHD15
         }
         return VideoParameters(
-            dimensions: preset.dimensions.flip(),
+            dimensions: preset.dimensions.flipped,
             maxBandwidth: screenShareMaxBandwidth,
             maxFps: preset.maxFps,
             simulcastConfig: screenShareSimulcastConfig
         )
     }
 
-    func emitEvent(name: String, data: [String: Any]) {
-        sendEvent(name, data)
+    func emit(event: EmitableEvents, data: [String: Any] = [:]) {
+        DispatchQueue.main.async { [weak self] in
+            self?.sendEvent(event.name, data)
+        }
     }
 
     func emit(warning: String) {
-        emitEvent(name: EmitableEvents.Warning, data: ["message": warning])
+        emit(event: .Warning, data: ["message": warning])
     }
 
     func emitEndpoints() {
-        let eventName = EmitableEvents.PeersUpdate
-        let EndpointsUpdateMap = [eventName: (try? getPeers()) ?? []]
-        emitEvent(name: eventName, data: EndpointsUpdateMap)
+        let event = EmitableEvents.PeersUpdate
+        let EndpointsUpdateMap = [event.name: (try? getPeers()) ?? []]
+        emit(event: event, data: EndpointsUpdateMap)
     }
 
     func onJoined(peerID: String, peersInRoom: [String: Endpoint]) {
@@ -692,6 +780,7 @@ class RNFishjamClient: FishjamClientListener {
         connectPromise?.resolve(nil)
         connectPromise = nil
         emitEndpoints()
+        peerStatus = .connected
     }
 
     func onJoinError(metadata: Any) {
@@ -712,9 +801,7 @@ class RNFishjamClient: FishjamClientListener {
             }
         }
 
-        RNFishjamClient.onTracksUpdateListeners.forEach {
-            $0.onTrackUpdate()
-        }
+        RNFishjamClient.tracksUpdateListenersManager.notifyListeners()
 
         emitEndpoints()
     }
@@ -753,6 +840,7 @@ class RNFishjamClient: FishjamClientListener {
                 "E_MEMBRANE_CONNECT", "Failed to connect: socket close, code: \(code), reason: \(reason)")
         }
         connectPromise = nil
+        peerStatus = .error
     }
 
     func onSocketError() {
@@ -764,7 +852,9 @@ class RNFishjamClient: FishjamClientListener {
 
     func onSocketOpen() {}
 
-    func onDisconnected() {}
+    func onDisconnected() {
+        peerStatus = .idle
+    }
 
     func getSimulcastConfigAsRNMap(_ simulcastConfig: SimulcastConfig) -> [String: Any] {
         return [
@@ -826,11 +916,11 @@ class RNFishjamClient: FishjamClientListener {
         default:
             deviceTypeString = deviceType.rawValue
         }
-        let eventName = EmitableEvents.AudioDeviceUpdate
-        emitEvent(
-            name: eventName,
+        let event = EmitableEvents.AudioDeviceUpdate
+        emit(
+            event: event,
             data: [
-                eventName: [
+                event.name: [
                     "selectedDevice": ["name": output.portName, "type": deviceTypeString],
                     "availableDevices": [],
                 ]
@@ -838,20 +928,20 @@ class RNFishjamClient: FishjamClientListener {
     }
 
     func onBandwidthEstimationChanged(estimation: Int) {
-        let eventName = EmitableEvents.BandwidthEstimation
-        emitEvent(name: eventName, data: [eventName: estimation])
+        let event = EmitableEvents.BandwidthEstimation
+        emit(event: event, data: [event.name: estimation])
     }
 
     func onReconnectionStarted() {
-        emitEvent(name: EmitableEvents.ReconnectionStarted, data: [:])
+        emit(event: .ReconnectionStarted)
     }
 
     func onReconnected() {
-        emitEvent(name: EmitableEvents.Reconnected, data: [:])
+        emit(event: .Reconnected)
     }
 
     func onReconnectionRetriesLimitReached() {
-        emitEvent(name: EmitableEvents.ReconnectionRetriesLimitReached, data: [:])
+        emit(event: .ReconnectionRetriesLimitReached)
     }
 
 }