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

package/ios/RNFishjamClient.swift

@@ -26,22 +26,23 @@ class RNFishjamClient: FishjamClientListener {
 
     var cameraId: String? = nil
 
-    var audioSessionMode: AVAudioSession.Mode = AVAudioSession.Mode.videoChat
+    var audioSessionMode: AVAudioSession.Mode = .videoChat
     var errorMessage: String?
 
+    var currentCamera: LocalCamera? { getLocalCameraTrack()?.currentCaptureDevice?.toLocalCamera() }
+
     private(set) var peerStatus: PeerStatus = .idle {
         didSet {
-            let event = EmitableEvents.PeerStatusChanged
-            emit(event: event, data: [event.name: peerStatus.rawValue])
+            emit(event: .peerStatusChanged(peerStatus: peerStatus))
         }
     }
 
-    let sendEvent: (_ eventName: String, _ data: [String: Any]) -> Void
+    let sendEvent: (_ eventName: String, _ data: [String: Any?]) -> Void
 
     static var tracksUpdateListenersManager = TracksUpdateListenersManager()
     static var localCameraTracksChangedListenersManager = LocalCameraTracksChangedListenersManager()
 
-    init(sendEvent: @escaping (_ eventName: String, _ data: [String: Any]) -> Void) {
+    init(sendEvent: @escaping (_ eventName: String, _ data: [String: Any?]) -> Void) {
         self.sendEvent = sendEvent
         NotificationCenter.default.addObserver(
             self,
@@ -214,7 +215,7 @@ class RNFishjamClient: FishjamClientListener {
 
         RNFishjamClient.fishjamClient?.connect(
             config: FishjamCloudClient.ConnectConfig(
-                websocketUrl: url, token: peerToken, peerMetadata: localUserMetadata,
+                websocketUrl: url, token: peerToken, peerMetadata: peerMetadata.toMetadata(),
                 reconnectConfig: reconnectConfig
             ))
 
@@ -239,23 +240,36 @@ class RNFishjamClient: FishjamClientListener {
         }
     }
 
-    func startCamera(config: CameraConfig) async throws {
-        try ensureCreated()
+    func startCamera(config: CameraConfig) async throws -> Bool {
+        #if targetEnvironment(simulator)
+            emit(
+                event: .warning(
+                    message: "Camera is not supported on simulator."))
+            return false
+        #else
+            try ensureCreated()
 
-        guard !isCameraInitialized else {
-            emit(warning: "Camera already started. You may only call startCamera once before leaveRoom is called.")
-            return
-        }
+            guard !isCameraInitialized else {
+                emit(
+                    event: .warning(
+                        message:
+                            "Camera already started. You may only call startCamera once before leaveRoom is called."))
 
-        guard await PermissionUtils.requestCameraPermission() else {
-            emit(warning: "Camera permission not granted.")
-            return
-        }
+                return true
+            }
 
-        let cameraTrack = try createCameraTrack(config: config)
-        setCameraTrackState(cameraTrack, enabled: config.cameraEnabled)
-        emitEndpoints()
-        isCameraInitialized = true
+            guard await PermissionUtils.requestCameraPermission() else {
+                emit(event: .warning(message: "Camera permission not granted."))
+                return false
+            }
+
+            let cameraTrack = try createCameraTrack(config: config)
+            cameraTrack.captureDeviceChangedListener = self
+            setCameraTrackState(cameraTrack, enabled: config.cameraEnabled)
+            emitEndpoints()
+            isCameraInitialized = true
+            return true
+        #endif
     }
 
     private func createCameraTrack(config: CameraConfig) throws -> LocalCameraTrack {
@@ -272,9 +286,9 @@ class RNFishjamClient: FishjamClientListener {
     private func setCameraTrackState(_ cameraTrack: LocalCameraTrack, enabled: Bool) {
         cameraTrack.enabled = enabled
         isCameraOn = enabled
-        let event = EmitableEvents.IsCameraOn
-        let isCameraEnabledMap = [event.name: enabled]
-        emit(event: event, data: isCameraEnabledMap)
+        emit(
+            event: .currentCameraChanged(
+                localCamera: cameraTrack.currentCaptureDevice?.toLocalCamera(), isCameraOn: enabled))
         RNFishjamClient.localCameraTracksChangedListenersManager.notifyListeners()
     }
 
@@ -301,12 +315,19 @@ class RNFishjamClient: FishjamClientListener {
         } else {
             try await startMicrophone()
         }
+
+        try updateLocalAudioTrackMetadata(metadata: [
+            "active": isMicrophoneOn,
+            "paused": !isMicrophoneOn,  //TODO: FCE-711
+            "type": "microphone",
+        ])
+
         return isMicrophoneOn
     }
 
     func startMicrophone() async throws {
         guard await PermissionUtils.requestMicrophonePermission() else {
-            emit(warning: "Microphone permission not granted.")
+            emit(event: .warning(message: "Microphone permission not granted."))
             return
         }
         let microphoneTrack = RNFishjamClient.fishjamClient!.createAudioTrack(metadata: Metadata())
@@ -318,9 +339,7 @@ class RNFishjamClient: FishjamClientListener {
     private func setMicrophoneTrackState(_ microphoneTrack: LocalAudioTrack, enabled: Bool) {
         microphoneTrack.enabled = enabled
         isMicrophoneOn = enabled
-        let event = EmitableEvents.IsMicrophoneOn
-        let isMicrophoneOnMap = [event.name: enabled]
-        emit(event: event, data: isMicrophoneOnMap)
+        emit(event: .isMicrophoneOn(enabled: enabled))
     }
 
     func setAudioSessionMode() {
@@ -345,7 +364,7 @@ class RNFishjamClient: FishjamClientListener {
         try ensureCreated()
         try ensureConnected()
         guard isAppScreenShareOn == false else {
-            emit(warning: "Screensharing screen not available during screensharing app.")
+            emit(event: .warning(message: "Screensharing screen not available during screensharing app."))
             return
         }
         guard let screenShareExtensionBundleId = Bundle.main.infoDictionary?["ScreenShareExtensionBundleId"] as? String
@@ -383,7 +402,7 @@ class RNFishjamClient: FishjamClientListener {
             metadata: screenShareMetadata,
             canStart: {
                 if self.isAppScreenShareOn {
-                    self.emit(warning: "Screensharing screen not available during screensharing app.")
+                    self.emit(event: .warning(message: "Screensharing screen not available during screensharing app."))
                 }
                 return !self.isAppScreenShareOn
             },
@@ -418,9 +437,7 @@ class RNFishjamClient: FishjamClientListener {
 
     private func setScreenShareTrackState(enabled: Bool) throws {
         isScreenShareOn = enabled
-        let event = EmitableEvents.IsScreenShareOn
-        let isScreenShareEnabled = [event.name: enabled]
-        emit(event: event, data: isScreenShareEnabled)
+        emit(event: .isScreenShareOn(enabled: enabled))
     }
 
     func startScreenAppShare(screenShareOptions: ScreenShareOptions) throws {
@@ -449,7 +466,7 @@ class RNFishjamClient: FishjamClientListener {
 
     func toggleAppScreenShare(screenShareOptions: ScreenShareOptions) throws {
         guard isScreenShareOn == false else {
-            emit(warning: "App screensharing not available during screensharing.")
+            emit(event: .warning(message: "App screensharing not available during screensharing."))
             return
         }
         if getLocalScreenAppTrack() != nil {
@@ -462,9 +479,7 @@ class RNFishjamClient: FishjamClientListener {
     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)
+        emit(event: .isAppScreenShareOn(enabled: enabled))
     }
 
     //returns local endpoint and remote endpoints
@@ -480,7 +495,6 @@ class RNFishjamClient: FishjamClientListener {
             [
                 "id": endpoint.id,
                 "isLocal": endpoint.id == RNFishjamClient.fishjamClient!.getLocalEndpoint().id,
-                "type": endpoint.type,
                 "metadata": endpoint.metadata.toDict(),
                 "tracks": endpoint.tracks.values.compactMap { track -> [String: Any?]? in
                     switch track {
@@ -539,19 +553,7 @@ class RNFishjamClient: FishjamClientListener {
 
     func getCaptureDevices() -> [[String: Any]] {
         let devices = LocalCameraTrack.getCaptureDevices()
-        return devices.map { device -> [String: Any] in
-            let facingDirection =
-                switch device.position {
-                case .front: "front"
-                case .back: "back"
-                default: "unspecified"
-                }
-            return [
-                "id": device.uniqueID,
-                "name": device.localizedName,
-                "facingDirection": facingDirection,
-            ]
-        }
+        return devices.map { $0.toLocalCamera() }
     }
 
     func updatePeerMetadata(metadata: [String: Any]) throws {
@@ -571,7 +573,7 @@ class RNFishjamClient: FishjamClientListener {
         }
     }
 
-    func updateLocalAudioTrackMetadata(metadata: [String: Any]) throws {
+    private func updateLocalAudioTrackMetadata(metadata: [String: Any]) throws {
         try ensureAudioTrack()
         if let track = getLocalAudioTrack() {
             updateTrackMetadata(trackId: track.id, metadata: metadata)
@@ -604,13 +606,14 @@ class RNFishjamClient: FishjamClientListener {
         return SimulcastConfig(enabled: true, activeEncodings: updatedEncodings)
     }
 
-    func toggleScreenShareTrackEncoding(encoding: String) throws -> [String: Any] {
+    func toggleScreenShareTrackEncoding(encoding: String) throws -> [String: Any?] {
         try ensureScreenBroadcastTrack()
         if let track = getLocalScreenBroadcastTrack() {
             screenShareSimulcastConfig = try toggleTrackEncoding(
                 encoding: encoding, trackId: track.id, simulcastConfig: screenShareSimulcastConfig)
         }
-        return getSimulcastConfigAsRNMap(screenShareSimulcastConfig)
+
+        return EmitableEvent.simulcastConfigUpdate(simulcastConfig: screenShareSimulcastConfig).data
     }
 
     func setScreenShareTrackBandwidth(bandwidth: Int) throws {
@@ -634,7 +637,7 @@ class RNFishjamClient: FishjamClientListener {
         RNFishjamClient.fishjamClient?.setTargetTrackEncoding(trackId: trackId, encoding: trackEncoding)
     }
 
-    func toggleVideoTrackEncoding(encoding: String) throws -> [String: Any] {
+    func toggleVideoTrackEncoding(encoding: String) throws -> [String: Any?] {
         try ensureCameraTrack()
         try ensureConnected()
 
@@ -642,11 +645,10 @@ class RNFishjamClient: FishjamClientListener {
         videoSimulcastConfig = try toggleTrackEncoding(
             encoding: encoding, trackId: track.id, simulcastConfig: videoSimulcastConfig)
 
-        let event = EmitableEvents.SimulcastConfigUpdate
-        let simulcastConfigAsRNMap = getSimulcastConfigAsRNMap(videoSimulcastConfig)
-        emit(event: event, data: simulcastConfigAsRNMap)
+        let event = EmitableEvent.simulcastConfigUpdate(simulcastConfig: videoSimulcastConfig)
+        emit(event: event)
 
-        return simulcastConfigAsRNMap
+        return event.data
     }
 
     func setVideoTrackEncodingBandwidth(encoding: String, bandwidth: Int) throws {
@@ -759,20 +761,14 @@ class RNFishjamClient: FishjamClientListener {
         )
     }
 
-    func emit(event: EmitableEvents, data: [String: Any] = [:]) {
+    func emit(event: EmitableEvent) {
         DispatchQueue.main.async { [weak self] in
-            self?.sendEvent(event.name, data)
+            self?.sendEvent(event.event.name, event.data)
         }
     }
 
-    func emit(warning: String) {
-        emit(event: .Warning, data: ["message": warning])
-    }
-
     func emitEndpoints() {
-        let event = EmitableEvents.PeersUpdate
-        let EndpointsUpdateMap = [event.name: (try? getPeers()) ?? []]
-        emit(event: event, data: EndpointsUpdateMap)
+        emit(event: .peersUpdate(peersData: (try? getPeers()) ?? []))
     }
 
     func onJoined(peerID: String, peersInRoom: [String: Endpoint]) {
@@ -856,13 +852,6 @@ class RNFishjamClient: FishjamClientListener {
         peerStatus = .idle
     }
 
-    func getSimulcastConfigAsRNMap(_ simulcastConfig: SimulcastConfig) -> [String: Any] {
-        return [
-            "enabled": simulcastConfig.enabled,
-            "activeEncodings": simulcastConfig.activeEncodings.map { e in e.description },
-        ]
-    }
-
     func selectAudioSessionMode(sessionMode: String) throws {
         switch sessionMode {
         case "videoChat":
@@ -895,53 +884,29 @@ class RNFishjamClient: FishjamClientListener {
     }
 
     @objc func onRouteChangeNotification() {
-        let currentRoute = AVAudioSession.sharedInstance().currentRoute
-        let output = currentRoute.outputs[0]
-        let deviceType = output.portType
-        var deviceTypeString: String = ""
-
-        switch deviceType {
-        case .bluetoothA2DP, .bluetoothLE, .bluetoothHFP:
-            deviceTypeString = "bluetooth"
-            break
-        case .builtInSpeaker:
-            deviceTypeString = "speaker"
-            break
-        case .builtInReceiver:
-            deviceTypeString = "earpiece"
-            break
-        case .headphones:
-            deviceTypeString = "headphones"
-            break
-        default:
-            deviceTypeString = deviceType.rawValue
-        }
-        let event = EmitableEvents.AudioDeviceUpdate
-        emit(
-            event: event,
-            data: [
-                event.name: [
-                    "selectedDevice": ["name": output.portName, "type": deviceTypeString],
-                    "availableDevices": [],
-                ]
-            ] as [String: [String: Any]])
+        emit(event: .audioDeviceUpdate(currentRoute: AVAudioSession.sharedInstance().currentRoute))
     }
 
     func onBandwidthEstimationChanged(estimation: Int) {
-        let event = EmitableEvents.BandwidthEstimation
-        emit(event: event, data: [event.name: estimation])
+        emit(event: .bandwidthEstimation(estimation: estimation))
     }
 
     func onReconnectionStarted() {
-        emit(event: .ReconnectionStarted)
+        emit(event: .reconnectionStarted)
     }
 
     func onReconnected() {
-        emit(event: .Reconnected)
+        emit(event: .reconnected)
     }
 
     func onReconnectionRetriesLimitReached() {
-        emit(event: .ReconnectionRetriesLimitReached)
+        emit(event: .reconnectionRetriesLimitReached)
     }
 
 }
+
+extension RNFishjamClient: CameraCapturerDeviceChangedListener {
+    func onCaptureDeviceChanged(_ device: AVCaptureDevice?) {
+        emit(event: .currentCameraChanged(localCamera: device?.toLocalCamera(), isCameraOn: isCameraOn))
+    }
+}

package/ios/RNFishjamClientModule.swift

@@ -75,7 +75,7 @@ public class RNFishjamClientModule: Module {
     public func definition() -> ModuleDefinition {
         let rnFishjamClient: RNFishjamClient = {
             let client = RNFishjamClient {
-                (eventName: String, data: [String: Any]) in
+                (eventName: String, data: [String: Any?]) in
                 self.sendEvent(eventName, data)
             }
             client.create()
@@ -84,7 +84,7 @@ public class RNFishjamClientModule: Module {
 
         Name("RNFishjamClient")
 
-        Events(EmitableEvents.allEvents)
+        Events(EmitableEvent.allEvents)
 
         Property("peerStatus") {
             return rnFishjamClient.peerStatus.rawValue
@@ -102,6 +102,10 @@ public class RNFishjamClientModule: Module {
             return rnFishjamClient.getCaptureDevices()
         }
 
+        Property("currentCamera") {
+            return rnFishjamClient.currentCamera
+        }
+
         Property("isScreenShareOn") {
             return rnFishjamClient.isScreenShareOn
         }
@@ -164,10 +168,6 @@ public class RNFishjamClientModule: Module {
             try rnFishjamClient.updateLocalVideoTrackMetadata(metadata: metadata)
         }
 
-        AsyncFunction("updateAudioTrackMetadata") { (metadata: [String: Any]) in
-            try rnFishjamClient.updateLocalAudioTrackMetadata(metadata: metadata)
-        }
-
         AsyncFunction("updateScreenShareTrackMetadata") { (metadata: [String: Any]) in
             try rnFishjamClient.updateLocalScreenShareTrackMetadata(metadata: metadata)
         }

package/ios/Utils/PermissionUtils.swift

@@ -0,0 +1,16 @@
+import AVFoundation
+
+class PermissionUtils {
+    static func requestCameraPermission() async -> Bool { await requestAccessIfNeeded(for: .video) }
+    static func requestMicrophonePermission() async -> Bool { await requestAccessIfNeeded(for: .audio) }
+
+    private static func requestAccessIfNeeded(for mediaType: AVMediaType) async -> Bool {
+        let status = AVCaptureDevice.authorizationStatus(for: mediaType)
+
+        return if status == .notDetermined {
+            await AVCaptureDevice.requestAccess(for: mediaType)
+        } else {
+            status == .authorized
+        }
+    }
+}

package/ios/VideoPreviewView.swift

@@ -2,15 +2,14 @@ import ExpoModulesCore
 import FishjamCloudClient
 
 class VideoPreviewView: ExpoView, LocalCameraTrackChangedListener {
-    var videoView: VideoView? = nil
-    private var localVideoTrack: LocalCameraTrack? = nil
+    var videoView: VideoView!
+    private var localVideoTrack: LocalCameraTrack?
 
     required init(appContext: AppContext? = nil) {
         super.init(appContext: appContext)
         videoView = VideoView()
-        videoView?.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-        videoView?.clipsToBounds = true
-        addSubview(videoView!)
+        videoView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        videoView.clipsToBounds = true
     }
 
     private func trySetLocalCameraTrack() {
@@ -29,16 +28,18 @@ class VideoPreviewView: ExpoView, LocalCameraTrackChangedListener {
                     track is LocalCameraTrack
                 })?.value as? LocalCameraTrack
             self.localVideoTrack?.start()
-            self.videoView?.track = self.localVideoTrack
+            self.videoView.track = self.localVideoTrack
         }
     }
 
     override func willMove(toSuperview newSuperview: UIView?) {
         super.willMove(toSuperview: newSuperview)
         if newSuperview == nil {
+            videoView.removeFromSuperview()
             RNFishjamClient.localCameraTracksChangedListenersManager.remove(self)
             localVideoTrack?.stop()
         } else {
+            addSubview(videoView)
             RNFishjamClient.localCameraTracksChangedListenersManager.add(self)
             trySetLocalCameraTrack()
         }
@@ -48,26 +49,25 @@ class VideoPreviewView: ExpoView, LocalCameraTrackChangedListener {
         didSet {
             switch videoLayout {
             case "FIT":
-                self.videoView?.layout = .fit
+                videoView.layout = .fit
             case "FILL":
-                self.videoView?.layout = .fill
+                videoView.layout = .fill
             default:
-                self.videoView?.layout = .fill
+                videoView.layout = .fill
             }
         }
     }
 
     var mirrorVideo: Bool = false {
         didSet {
-            self.videoView?.mirror = mirrorVideo
+            videoView.mirror = mirrorVideo
         }
     }
 
     var captureDeviceId: String? = nil {
         didSet {
-            if let captureDeviceId = captureDeviceId {
-                localVideoTrack?.switchCamera(deviceId: captureDeviceId)
-            }
+            guard let captureDeviceId else { return }
+            localVideoTrack?.switchCamera(deviceId: captureDeviceId)
         }
     }
 

package/ios/VideoRendererView.swift

@@ -3,42 +3,39 @@ import ExpoModulesCore
 import FishjamCloudClient
 
 class VideoRendererView: ExpoView, TrackUpdateListener {
-    var videoView: VideoView? = nil
-    var cancellableEndpoints: Cancellable? = nil
+    var videoView: VideoView!
+    var cancellableEndpoints: Cancellable?
 
     required init(appContext: AppContext? = nil) {
         super.init(appContext: appContext)
-        RNFishjamClient.tracksUpdateListenersManager.add(self)
         videoView = VideoView()
-        videoView?.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-        videoView?.clipsToBounds = true
-        addSubview(videoView!)
-    }
-
-    deinit {
-        RNFishjamClient.tracksUpdateListenersManager.remove(self)
+        videoView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        videoView.clipsToBounds = true
     }
 
     override func willMove(toSuperview newSuperview: UIView?) {
         super.willMove(toSuperview: newSuperview)
 
-        if newSuperview != nil {
+        if newSuperview == nil {
+            videoView.removeFromSuperview()
+            RNFishjamClient.tracksUpdateListenersManager.remove(self)
+        } else {
+            addSubview(videoView)
+            RNFishjamClient.tracksUpdateListenersManager.add(self)
             updateVideoTrack()
         }
     }
 
     func updateVideoTrack() {
-        DispatchQueue.main.async {
-            if self.superview != nil {
-                for endpoint in RNFishjamClient.getLocalAndRemoteEndpoints() {
-                    if let track = endpoint.tracks[self.trackId] as? VideoTrack {
-                        if let track = track as? LocalCameraTrack {
-                            self.mirrorVideo = track.isFrontCamera
-                        }
-                        self.videoView?.track = track
-                        return
-                    }
+        DispatchQueue.main.async { [weak self] in
+            guard let self, self.superview != nil else { return }
+            for endpoint in RNFishjamClient.getLocalAndRemoteEndpoints() {
+                guard let track = endpoint.tracks[self.trackId] as? VideoTrack else { continue }
+                if let track = track as? LocalCameraTrack {
+                    self.mirrorVideo = track.isFrontCamera
                 }
+                self.videoView.track = track
+                return
             }
         }
     }
@@ -57,11 +54,11 @@ class VideoRendererView: ExpoView, TrackUpdateListener {
         didSet {
             switch videoLayout {
             case "FIT":
-                self.videoView?.layout = .fit
+                videoView.layout = .fit
             case "FILL":
-                self.videoView?.layout = .fill
+                videoView.layout = .fill
             default:
-                self.videoView?.layout = .fill
+                videoView.layout = .fill
             }
 
         }
@@ -69,7 +66,13 @@ class VideoRendererView: ExpoView, TrackUpdateListener {
 
     var mirrorVideo: Bool = false {
         didSet {
-            self.videoView?.mirror = mirrorVideo
+            videoView.mirror = mirrorVideo
+        }
+    }
+
+    var checkVisibilityTimeInterval: TimeInterval? {
+        didSet {
+            videoView.checkVisibilityTimeInterval = checkVisibilityTimeInterval
         }
     }
 }

package/ios/VideoRendererViewModule.swift

@@ -5,12 +5,16 @@ public class VideoRendererViewModule: Module {
         Name("VideoRendererViewModule")
 
         View(VideoRendererView.self) {
-            Prop("trackId") { (view: VideoRendererView, prop: String) in
-                view.trackId = prop
+            Prop("trackId") { (view, trackId) in
+                view.trackId = trackId
             }
 
-            Prop("videoLayout") { (view: VideoRendererView, prop: String) in
-                view.videoLayout = prop
+            Prop("videoLayout") { (view, videoLayout) in
+                view.videoLayout = videoLayout
+            }
+
+            Prop("skipRenderOutsideVisibleArea") { (view, skipRenderOutsideVisibleArea) in
+                view.checkVisibilityTimeInterval = skipRenderOutsideVisibleArea ? 1 : nil
             }
         }
     }

package/ios/extensions/AVCaptureDevice.swift

@@ -0,0 +1,20 @@
+import AVKit
+import FishjamCloudClient
+
+public typealias LocalCamera = [String: Any]
+
+extension AVCaptureDevice {
+    func toLocalCamera() -> LocalCamera {
+        let facingDirection =
+            switch position {
+            case .front: "front"
+            case .back: "back"
+            default: "unspecified"
+            }
+        return [
+            "id": uniqueID,
+            "name": localizedName,
+            "facingDirection": facingDirection,
+        ]
+    }
+}

package/ios/managers/LocalCameraTracksChangedListenersManager.swift

@@ -0,0 +1,23 @@
+import Foundation
+
+protocol LocalCameraTrackChangedListener: AnyObject {
+    func onLocalCameraTrackChanged()
+}
+
+class LocalCameraTracksChangedListenersManager {
+    private var listeners: [LocalCameraTrackChangedListener] = []
+
+    func add(_ listener: LocalCameraTrackChangedListener) {
+        listeners.append(listener)
+    }
+
+    func remove(_ listener: LocalCameraTrackChangedListener) {
+        listeners.removeAll { $0 === listener }
+    }
+
+    func notifyListeners() {
+        for listener in listeners {
+            listener.onLocalCameraTrackChanged()
+        }
+    }
+}

package/ios/managers/TracksUpdateListenersManager.swift

@@ -0,0 +1,21 @@
+protocol TrackUpdateListener: AnyObject {
+    func onTracksUpdate()
+}
+
+class TracksUpdateListenersManager {
+    private var listeners: [TrackUpdateListener] = []
+
+    func add(_ listener: TrackUpdateListener) {
+        listeners.append(listener)
+    }
+
+    func remove(_ listener: TrackUpdateListener) {
+        listeners.removeAll { $0 === listener }
+    }
+
+    func notifyListeners() {
+        for listener in listeners {
+            listener.onTracksUpdate()
+        }
+    }
+}