react-native-theoplayer 1.7.1 → 1.8.0

package/ios/THEOplayerRCTView.swift

@@ -3,38 +3,53 @@
 import Foundation
 import UIKit
 import THEOplayerSDK
+
+#if CHROMECAST
+import GoogleCast
+#endif
  
 class THEOplayerRCTView: UIView {
     // MARK: Members
     private var player: THEOplayer?
     private var mainEventHandler: THEOplayerRCTViewMainEventHandler
     private var textTrackEventHandler: THEOplayerRCTViewTextTrackEventHandler
+    private var mediaTrackEventHandler: THEOplayerRCTViewMediaTrackEventHandler
     private var adEventHandler: THEOplayerRCTViewAdEventHandler
+    private var castEventHandler: THEOplayerRCTViewCastEventHandler
     
     // MARK: Bridged props
     private var src: SourceDescription?
     private var license: String?
     private var licenseUrl: String?
     private var chromeless: Bool = true
-    private var adSUIEnabled: Bool = true
-    private var adPreloadType: THEOplayerSDK.AdPreloadType = THEOplayerSDK.AdPreloadType.MIDROLL_AND_POSTROLL
-    private var googleImaUsesNativeIma: Bool = true
     private var config: THEOplayerConfiguration?
-    private var paused: Bool = false
-    private var muted: Bool = true
+    private var paused: Bool = true
+    private var muted: Bool = false
     private var playbackRate: Double = 1.0
     private var selectedTextTrackUid: Int = 0
     private var selectedVideoTrackUid: Int = 0
     private var selectedAudioTrackUid: Int = 0
     private var seek: Double? = nil                  // in msec
     private var fullscreen: Bool = false
+    private var chromecastReceiverApplicationId: String?
+    
+#if os(iOS)
+    private var castStrategy: THEOplayerSDK.CastStrategy = THEOplayerSDK.CastStrategy.manual
+#endif
+#if os(iOS) && ADS && (GOOGLE_IMA || GOOGLE_DAI)
+    private var adSUIEnabled: Bool = true
+    private var googleImaUsesNativeIma: Bool = true
+    private var adPreloadType: THEOplayerSDK.AdPreloadType = .MIDROLL_AND_POSTROLL
+#endif
     
     // MARK: - Initialisation / view setup
     init() {
         // create event handlers to maintain event props
         self.mainEventHandler = THEOplayerRCTViewMainEventHandler()
         self.textTrackEventHandler = THEOplayerRCTViewTextTrackEventHandler()
+        self.mediaTrackEventHandler = THEOplayerRCTViewMediaTrackEventHandler()
         self.adEventHandler = THEOplayerRCTViewAdEventHandler()
+        self.castEventHandler = THEOplayerRCTViewCastEventHandler()
         
         super.init(frame: .zero)
     }
@@ -42,7 +57,10 @@ class THEOplayerRCTView: UIView {
     func destroy() {
         self.mainEventHandler.destroy()
         self.textTrackEventHandler.destroy()
+        self.mediaTrackEventHandler.destroy()
         self.adEventHandler.destroy()
+        self.castEventHandler.destroy()
+        
         self.player?.destroy()
         self.player = nil
         if DEBUG_THEOPLAYER_INTERACTION { print("[NATIVE] THEOplayer instance destroyed.") }
@@ -54,6 +72,15 @@ class THEOplayerRCTView: UIView {
         }
         return player.ads
     }
+  
+#if os(iOS)
+    func cast() -> Cast? {
+        guard let player = self.player else {
+            return nil
+        }
+        return player.cast
+    }
+#endif
     
     required init?(coder aDecoder: NSCoder) {
         fatalError("[NATIVE] init(coder:) has not been implemented")
@@ -95,21 +122,29 @@ class THEOplayerRCTView: UIView {
             return
         }
         
-        // reset player for new source
-        if self.player != nil {
+        var isCasting = false
+#if os(iOS)
+        isCasting = self.player?.cast?.casting ?? false // TO FIX: remove 'isCasting' workaround
+#endif
+        
+        if !isCasting || self.player == nil {
             self.player?.destroy()
             self.player = nil
-        }
-        DispatchQueue.main.async {
-            self.initPlayer()
-            if let player = self.player {
-                // couple player instance to event handlers
-                self.mainEventHandler.setPlayer(player)
-                self.textTrackEventHandler.setPlayer(player)
-                self.adEventHandler.setPlayer(player)
-                // couple player instance to view
-                player.addAsSubview(of: self)
+            DispatchQueue.main.async {
+                self.initPlayer()
+                if let player = self.player {
+                    // couple player instance to event handlers
+                    self.mainEventHandler.setPlayer(player)
+                    self.textTrackEventHandler.setPlayer(player)
+					self.mediaTrackEventHandler.setPlayer(player)
+                    self.adEventHandler.setPlayer(player)
+                    self.castEventHandler.setPlayer(player)
+                    // couple player instance to view
+                    player.addAsSubview(of: self)
+                }
+                self.syncAllPlayerProps()
             }
+        } else {
             self.syncAllPlayerProps()
         }
     }
@@ -118,6 +153,7 @@ class THEOplayerRCTView: UIView {
         if DEBUG_THEOPLAYER_INTERACTION { print("[NATIVE] 'lazy' init THEOplayer instance") }
 #if os(tvOS)
         self.player = THEOplayer(configuration: THEOplayerConfiguration(chromeless: self.chromeless,
+                                                                        ads: self.initAdsConfiguration(),
                                                                         license: self.license,
                                                                         licenseUrl: self.licenseUrl,
                                                                         pip: nil))
@@ -128,24 +164,48 @@ class THEOplayerRCTView: UIView {
                                                                         cssPaths: cssPaths,
                                                                         pip: nil,
                                                                         ads: self.initAdsConfiguration(),
+                                                                        cast: self.initCastConfiguration(),
                                                                         license: self.license,
                                                                         licenseUrl: self.licenseUrl))
 #endif
     }
-    
+
     private func initAdsConfiguration() -> AdsConfiguration? {
-#if ADS && (GOOGLE_IMA || GOOGLE_DAI)
-        let googleIMAConfiguration = GoogleIMAConfiguration()
+#if os(iOS) && ADS && (GOOGLE_IMA || GOOGLE_DAI)
+        // NOTE: GoogleIMAAdsConfiguration, GoogleDAIAdsConfigurationBuilder, GoogleDAIAdsConfigurationBuilder require iOS SDK 4.5.1 or higher
+        let googleIMAAdsConfiguration = GoogleIMAAdsConfiguration()
+        googleIMAAdsConfiguration.useNativeIma = self.googleImaUsesNativeIma
+        googleIMAAdsConfiguration.disableUI = !self.adSUIEnabled
+        let daiBuilder = GoogleDAIAdsConfigurationBuilder()
+        daiBuilder.disableUI = !self.adSUIEnabled
+        daiBuilder.enableBackgroundPlayback = true
+        let googleDaiAdsConfiguration = daiBuilder.build()
+        return AdsConfiguration(showCountdown: self.adSUIEnabled,
+                                preload: self.adPreloadType,
+                                googleIma: googleIMAAdsConfiguration,
+                                googleDai: googleDaiAdsConfiguration)
+        
+        // For lower iOS SDK versions replace the above with:
+        /*let googleIMAConfiguration = GoogleIMAConfiguration()
         googleIMAConfiguration.useNativeIma = self.googleImaUsesNativeIma
         googleIMAConfiguration.disableUI = !self.adSUIEnabled
         return AdsConfiguration(showCountdown: self.adSUIEnabled,
                                 preload: self.adPreloadType,
-                                googleImaConfiguration: googleIMAConfiguration)
+                                googleImaConfiguration: googleIMAConfiguration)*/
+        
+#elseif os(tvOS) && ADS && GOOGLE_IMA
+        return AdsConfiguration()
 #else
         return nil
 #endif
-        
     }
+
+#if os(iOS)
+    private func initCastConfiguration() -> CastConfiguration? {
+        // prepare the config
+        return CastConfiguration(strategy: self.castStrategy)
+    }
+#endif
     
     private func syncPlayerSrc() {
         // set sourceDescription on player
@@ -161,6 +221,7 @@ class THEOplayerRCTView: UIView {
         self.license = configDict["license"] as? String
         self.licenseUrl = configDict["licenseUrl"] as? String
         self.chromeless = configDict["chromeless"] as? Bool ?? true
+#if os(iOS) && ADS && (GOOGLE_IMA || GOOGLE_DAI)
         if let adsConfig = configDict["ads"] as? NSDictionary {
             self.adSUIEnabled = adsConfig["uiEnabled"] as? Bool ?? true
             if let adPreloadType = adsConfig["preload"] as? String {
@@ -170,6 +231,27 @@ class THEOplayerRCTView: UIView {
                 self.googleImaUsesNativeIma = googleImaConfiguration["useNativeIma"] as? Bool ?? true
             }
         }
+#endif
+#if os(iOS)
+        if let castConfig = configDict["cast"] as? NSDictionary {
+            if let castStrategy = castConfig["strategy"] as? String {
+                switch castStrategy {
+                case "auto":
+                    self.castStrategy = THEOplayerSDK.CastStrategy.auto
+                case "manual":
+                    self.castStrategy = THEOplayerSDK.CastStrategy.manual
+                case "disabled":
+                    self.castStrategy = THEOplayerSDK.CastStrategy.disabled
+                default :
+                    self.castStrategy = THEOplayerSDK.CastStrategy.manual
+                }
+            }
+            if let chromecastConfig = castConfig["chromecast"] as? NSDictionary,
+                let castReceiverApplicationId = chromecastConfig["appID"] as? String {
+                self.chromecastReceiverApplicationId = castReceiverApplicationId
+            }
+        }
+#endif
         if DEBUG_PROP_UPDATES  { print("[NATIVE] config prop updated.") }
     }
     
@@ -475,6 +557,20 @@ class THEOplayerRCTView: UIView {
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeTextTrackEvent prop set.") }
     }
     
+    // MARK: - Listener based MEDIATRACK event bridging
+    
+    @objc(setOnNativeMediaTrackListEvent:)
+    func setOnNativeMediaTrackListEvent(nativeMediaTrackListEvent: @escaping RCTDirectEventBlock) {
+        self.mediaTrackEventHandler.onNativeMediaTrackListEvent = nativeMediaTrackListEvent
+        if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeMediaTrackListEvent prop set.") }
+    }
+    
+    @objc(setOnNativeMediaTrackEvent:)
+    func setOnNativeMediaTrackEvent(nativeMediaTrackEvent: @escaping RCTDirectEventBlock) {
+        self.mediaTrackEventHandler.onNativeMediaTrackEvent = nativeMediaTrackEvent
+        if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeMediaTrackEvent prop set.") }
+    }
+    
     // MARK: - Listener based AD event bridging
     
     @objc(setOnNativeAdEvent:)
@@ -482,4 +578,12 @@ class THEOplayerRCTView: UIView {
         self.adEventHandler.onNativeAdEvent = nativeAdEvent
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeAdEvent prop set.") }
     }
+    
+    // MARK: - Listener based CAST event bridging
+    
+    @objc(setOnNativeCastEvent:)
+    func setOnNativeCastEvent(nativeCastEvent: @escaping RCTDirectEventBlock) {
+        self.castEventHandler.onNativeCastEvent = nativeCastEvent
+        if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeCastEvent prop set.") }
+    }
 }

package/ios/THEOplayerRCTViewAdEventHandler.swift

@@ -37,9 +37,7 @@ class THEOplayerRCTViewAdEventHandler {
     // MARK: - destruction
     func destroy() {
         // dettach listeners
-#if ADS && (GOOGLE_IMA || GOOLGE_DAI)
         self.dettachListeners()
-#endif
     }
     
     // MARK: - player setup / breakdown
@@ -47,9 +45,7 @@ class THEOplayerRCTViewAdEventHandler {
         self.player = player;
         
         // attach listeners
-#if ADS && (GOOGLE_IMA || GOOLGE_DAI)
         self.attachListeners()
-#endif
     }
     
     // MARK: - attach/dettach Listeners
@@ -57,7 +53,8 @@ class THEOplayerRCTViewAdEventHandler {
         guard let player = self.player else {
             return
         }
-
+        
+#if ADS && (GOOGLE_IMA || GOOGLE_DAI)
         // AD_BEGIN
         self.adBeginListener = player.ads.addEventListener(type: AdsEventTypes.AD_BEGIN) { [weak self] event in
             if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_BEGIN event from THEOplayer Ads") }
@@ -174,6 +171,8 @@ class THEOplayerRCTViewAdEventHandler {
             }
         }
         if DEBUG_EVENTHANDLER { print("[NATIVE] AdThirdQuartile listener attached to THEOplayer.ads") }
+#endif
+        
     }
     
     private func dettachListeners() {
@@ -181,6 +180,7 @@ class THEOplayerRCTViewAdEventHandler {
             return
         }
         
+#if ADS && (GOOGLE_IMA || GOOGLE_DAI)
         // AD_BEGIN
         if let adBeginListener = self.adBeginListener {
             player.ads.removeEventListener(type: AdsEventTypes.AD_BEGIN, listener: adBeginListener)
@@ -234,5 +234,7 @@ class THEOplayerRCTViewAdEventHandler {
             player.ads.removeEventListener(type: AdsEventTypes.AD_LOADED, listener: adLoadedListener)
             if DEBUG_EVENTHANDLER { print("[NATIVE] adLoadedListener listener dettached from THEOplayer.ads") }
         }
+#endif
+
     }
 }

package/ios/THEOplayerRCTViewCastEventHandler.swift

@@ -0,0 +1,124 @@
+// THEOplayerRCTViewCastEventHandler.swift
+
+import Foundation
+import THEOplayerSDK
+
+let CAST_EVENT_PROP_TYPE: String = "type"
+let CAST_EVENT_PROP_STATE: String = "state"
+let CAST_EVENT_PROP_ERROR: String = "error"
+let CAST_EVENT_PROP_ERROR_CODE: String = "errorCode"
+let CAST_EVENT_PROP_ERROR_DESCRIPTION: String = "description"
+
+let EVENT_TYPE_CHROMECAST_STATE_CHANGE: String = "chromecaststatechange"
+let EVENT_TYPE_CHROMECAST_ERROR: String = "chromecasterror"
+let EVENT_TYPE_AIRPLAY_STATE_CHANGE: String = "airplaystatechange"
+
+class THEOplayerRCTViewCastEventHandler {
+    // MARK: Members
+    private weak var player: THEOplayer?
+        
+    // MARK: Events
+    var onNativeCastEvent: RCTDirectEventBlock?
+    
+    // MARK: Cast Listeners
+    private var chromecastStateChangeListener: EventListener?
+    private var chromecastErrorListener: EventListener?
+    private var airplayStateChangeListener: EventListener?
+    
+    
+    // MARK: - destruction
+    func destroy() {
+        // dettach listeners
+        self.dettachListeners()
+    }
+    
+    // MARK: - player setup / breakdown
+    func setPlayer(_ player: THEOplayer) {
+        self.player = player;
+        
+        // attach listeners
+        self.attachListeners()
+    }
+    
+    // MARK: - attach/dettach Listeners
+    private func attachListeners() {
+        guard let player = self.player else {
+            return
+        }
+        
+#if os(iOS) && CHROMECAST
+        // CHROMECAST STATE_CHANGE
+        self.chromecastStateChangeListener = player.cast?.chromecast?.addEventListener(type: ChromecastEventTypes.STATE_CHANGE) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received Chromecast STATE_CHANGE event from THEOplayer cast.chromecast") }
+            if let forwardedCastEvent = self?.onNativeCastEvent {
+                let newCastState = event.state._rawValue
+                if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] New Chromecast state: \(newCastState)") }
+                forwardedCastEvent([
+                    CAST_EVENT_PROP_TYPE: EVENT_TYPE_CHROMECAST_STATE_CHANGE,
+                    CAST_EVENT_PROP_STATE: newCastState
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] Chromecast StateChange listener attached to THEOplayer cast.chromecast") }
+        
+        // CHROMECAST ERROR
+        self.chromecastErrorListener = player.cast?.chromecast?.addEventListener(type: ChromecastEventTypes.ERROR) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received Chromecast ERROR event from THEOplayer cast.chromecast") }
+            if let forwardedCastEvent = self?.onNativeCastEvent {
+                let error = event.error
+                forwardedCastEvent([
+                    CAST_EVENT_PROP_TYPE: EVENT_TYPE_CHROMECAST_ERROR,
+                    CAST_EVENT_PROP_ERROR: [
+                        CAST_EVENT_PROP_ERROR_CODE: error.errorCode._rawValue,
+                        CAST_EVENT_PROP_ERROR_DESCRIPTION: error.description ?? ""
+                    ]
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] Chromecast Error listener attached to THEOplayer cast.chromecast") }
+#endif
+        
+#if os(iOS)
+        // AIRPLAY STATE_CHANGE
+        self.airplayStateChangeListener = player.cast?.airPlay?.addEventListener(type: AirPlayEventTypes.STATE_CHANGE) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received Airplay STATE_CHANGE event from THEOplayer cast.airplay") }
+            if let forwardedCastEvent = self?.onNativeCastEvent,
+               let castState = event.state {
+                if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] New Airplay state: \(castState)") }
+                forwardedCastEvent([
+                    CAST_EVENT_PROP_TYPE: EVENT_TYPE_AIRPLAY_STATE_CHANGE,
+                    CAST_EVENT_PROP_STATE: castState._rawValue
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] Airplay StateChange listener attached to THEOplayer cast.airplay") }
+#endif
+    }
+
+    
+    private func dettachListeners() {
+        guard let player = self.player else {
+            return
+        }
+
+#if os(iOS) && CHROMECAST
+        // CHROMECAST STATE_CHANGE
+        if let chromecastStateChangeListener = self.chromecastStateChangeListener {
+            player.cast?.chromecast?.removeEventListener(type: ChromecastEventTypes.STATE_CHANGE, listener: chromecastStateChangeListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] Chromecast StateChange listener dettached from THEOplayer cast.chromecast") }
+        }
+        if let chromecastErrorListener = self.chromecastErrorListener {
+            player.cast?.chromecast?.removeEventListener(type: ChromecastEventTypes.ERROR, listener: chromecastErrorListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] Chromecast Error listener dettached from THEOplayer cast.chromecast") }
+        }
+#endif
+        
+#if os(iOS)
+        // AIRPLAY STATE_CHANGE
+        if let airplayStateChangeListener = self.airplayStateChangeListener {
+            player.cast?.airPlay?.removeEventListener(type: AirPlayEventTypes.STATE_CHANGE, listener: airplayStateChangeListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] Airplay StateChange listener dettached from THEOplayer cast.airplay") }
+        }
+#endif
+    }
+}

package/ios/THEOplayerRCTViewMainEventHandler.swift

@@ -242,7 +242,7 @@ class THEOplayerRCTViewMainEventHandler {
         self.loadedMetadataListener = player.addEventListener(type: PlayerEventTypes.LOADED_META_DATA) { [weak self] event in
             if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received LOADED_META_DATA event from THEOplayer") }
             if let forwardedLoadedMetadataEvent = self?.onNativeLoadedMetadata {
-                let metadata = THEOplayerRCTMetadataAggregator.aggregateMetadata(player: player)
+                let metadata = THEOplayerRCTTrackMetadataAggregator.aggregateTrackMetadata(player: player)
                 print(metadata)
                 forwardedLoadedMetadataEvent(metadata)
             }

package/ios/THEOplayerRCTViewMediaTrackEventHandler.swift

@@ -0,0 +1,185 @@
+// THEOplayerRCTViewMediaTrackEventHandler.swift
+
+import Foundation
+import THEOplayerSDK
+
+class THEOplayerRCTViewMediaTrackEventHandler {
+    // MARK: Members
+    private weak var player: THEOplayer?
+        
+    // MARK: Events
+    var onNativeMediaTrackListEvent: RCTDirectEventBlock?
+    var onNativeMediaTrackEvent: RCTDirectEventBlock?       // currently not in use on iOS THEOplayerSDK
+   
+    // MARK: mediaTrackList Listeners
+    private var audioAddTrackListener: EventListener?
+    private var audioRemoveTrackListener: EventListener?
+    private var audioChangeTrackListener: EventListener?
+    private var videoAddTrackListener: EventListener?
+    private var videoRemoveTrackListener: EventListener?
+    private var videoChangeTrackListener: EventListener?
+    
+    // MARK: mediaTrack listeners (attached dynamically to new mediatracks)
+    private var audioChangeTrackListeners: [Int:EventListener] = [:]
+    private var videoChangeTrackListeners: [Int:EventListener] = [:]
+    
+    
+    // MARK: - destruction
+    func destroy() {
+        // dettach listeners
+        self.dettachListeners()
+    }
+    
+    // MARK: - player setup / breakdown
+    func setPlayer(_ player: THEOplayer) {
+        self.player = player;
+        
+        // attach listeners
+        self.attachListeners()
+    }
+    
+    // MARK: - attach/dettach mediaTrackList Listeners
+    private func attachListeners() {
+        guard let player = self.player else {
+            return
+        }
+        
+        // AUDIO ADD_TRACK
+        self.audioAddTrackListener = player.audioTracks.addEventListener(type: AudioTrackListEventTypes.ADD_TRACK) { [weak self] event in
+            guard let welf = self else { return }
+            if let forwardedMediaTrackListEvent = welf.onNativeMediaTrackListEvent,
+               let audioTrack = event.track as? AudioTrack {
+                if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received ADD_TRACK event from THEOplayer audioTrack list: trackUid = \(audioTrack.uid)") }
+                // trigger tracklist event
+                forwardedMediaTrackListEvent([
+                    "track" : THEOplayerRCTTrackMetadataAggregator.aggregatedAudioTrackInfo(audioTrack: audioTrack),
+                    "type" : TrackListEventType.ADD_TRACK.rawValue,
+                    "trackType": MediaTrackType.AUDIO.rawValue
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AddTrack listener attached to THEOplayer audioTrack list") }
+        
+        // AUDIO REMOVE_TRACK
+        self.audioRemoveTrackListener = player.audioTracks.addEventListener(type: AudioTrackListEventTypes.REMOVE_TRACK) { [weak self] event in
+            guard let welf = self else { return }
+            if let forwardedMediaTrackListEvent = welf.onNativeMediaTrackListEvent,
+               let audioTrack = event.track as? AudioTrack {
+                if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received REMOVE_TRACK event from THEOplayer audioTrack list: trackUid = \(audioTrack.uid)") }
+                // trigger tracklist event
+                forwardedMediaTrackListEvent([
+                    "track" : THEOplayerRCTTrackMetadataAggregator.aggregatedAudioTrackInfo(audioTrack: audioTrack),
+                    "type" : TrackListEventType.REMOVE_TRACK.rawValue,
+                    "trackType": MediaTrackType.AUDIO.rawValue
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] RemoveTrack listener attached to THEOplayer audioTrack list") }
+        
+        // AUDIO CHANGE
+        self.audioChangeTrackListener = player.audioTracks.addEventListener(type: AudioTrackListEventTypes.CHANGE) { [weak self] event in
+            guard let welf = self else { return }
+            if let forwardedMediaTrackListEvent = welf.onNativeMediaTrackListEvent,
+               let audioTrack = event.track as? AudioTrack {
+                if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received CHANGE event from THEOplayer audioTrack list: trackUid = \(audioTrack.uid)") }
+                // trigger tracklist event
+                forwardedMediaTrackListEvent([
+                    "track" : THEOplayerRCTTrackMetadataAggregator.aggregatedAudioTrackInfo(audioTrack: audioTrack),
+                    "type" : TrackListEventType.CHANGE_TRACK.rawValue,
+                    "trackType": MediaTrackType.AUDIO.rawValue
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] ChangeTrack listener attached to THEOplayer audioTrack list") }
+        
+        // VIDEO ADD_TRACK
+        self.videoAddTrackListener = player.videoTracks.addEventListener(type: VideoTrackListEventTypes.ADD_TRACK) { [weak self] event in
+            guard let welf = self else { return }
+            if let forwardedMediaTrackListEvent = welf.onNativeMediaTrackListEvent,
+               let videoTrack = event.track as? VideoTrack {
+                if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received ADD_TRACK event from THEOplayer videoTrack list: trackUid = \(videoTrack.uid)") }
+                // trigger tracklist event
+                forwardedMediaTrackListEvent([
+                    "track" : THEOplayerRCTTrackMetadataAggregator.aggregatedVideoTrackInfo(videoTrack: videoTrack),
+                    "type" : TrackListEventType.ADD_TRACK.rawValue,
+                    "trackType": MediaTrackType.VIDEO.rawValue
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AddTrack listener attached to THEOplayer videoTrack list") }
+        
+        // VIDEO REMOVE_TRACK
+        self.videoRemoveTrackListener = player.videoTracks.addEventListener(type: VideoTrackListEventTypes.REMOVE_TRACK) { [weak self] event in
+            guard let welf = self else { return }
+            if let forwardedMediaTrackListEvent = welf.onNativeMediaTrackListEvent,
+               let videoTrack = event.track as? VideoTrack {
+                if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received REMOVE_TRACK event from THEOplayer videoTrack list: trackUid = \(videoTrack.uid)") }
+                // trigger tracklist event
+                forwardedMediaTrackListEvent([
+                    "track" : THEOplayerRCTTrackMetadataAggregator.aggregatedVideoTrackInfo(videoTrack: videoTrack),
+                    "type" : TrackListEventType.REMOVE_TRACK.rawValue,
+                    "trackType": MediaTrackType.VIDEO.rawValue
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] RemoveTrack listener attached to THEOplayer videoTrack list") }
+        
+        // VIDEO CHANGE
+        self.videoChangeTrackListener = player.videoTracks.addEventListener(type: VideoTrackListEventTypes.CHANGE) { [weak self] event in
+            guard let welf = self else { return }
+            if let forwardedMediaTrackListEvent = welf.onNativeMediaTrackListEvent,
+               let videoTrack = event.track as? VideoTrack {
+                if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received CHANGE event from THEOplayer videoTrack list: trackUid = \(videoTrack.uid)") }
+                // trigger tracklist event
+                forwardedMediaTrackListEvent([
+                    "track" : THEOplayerRCTTrackMetadataAggregator.aggregatedVideoTrackInfo(videoTrack: videoTrack),
+                    "type" : TrackListEventType.CHANGE_TRACK.rawValue,
+                    "trackType": MediaTrackType.VIDEO.rawValue
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] ChangeTrack listener attached to THEOplayer audioTrack list") }
+    }
+    
+    private func dettachListeners() {
+        guard let player = self.player else {
+            return
+        }
+        
+        // AUDIO ADD_TRACK
+        if let audioAddTrackListener = self.audioAddTrackListener {
+            player.audioTracks.removeEventListener(type: AudioTrackListEventTypes.ADD_TRACK, listener: audioAddTrackListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] AddTrack listener dettached from THEOplayer audioTrack list") }
+        }
+        
+        // AUDIO REMOVE_TRACK
+        if let audioRemoveTrackListener = self.audioRemoveTrackListener {
+            player.audioTracks.removeEventListener(type: AudioTrackListEventTypes.REMOVE_TRACK, listener: audioRemoveTrackListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] RemoveTrack listener dettached from THEOplayer audioTrack list") }
+        }
+        
+        // AUDIO CHANGE
+        if let audioChangeTrackListener = self.audioChangeTrackListener {
+            player.audioTracks.removeEventListener(type: AudioTrackListEventTypes.CHANGE, listener: audioChangeTrackListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] ChangeTrack listener dettached from THEOplayer audioTrack list") }
+        }
+        
+        // VIDEO ADD_TRACK
+        if let videoAddTrackListener = self.videoAddTrackListener {
+            player.videoTracks.removeEventListener(type: VideoTrackListEventTypes.ADD_TRACK, listener: videoAddTrackListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] AddTrack listener dettached from THEOplayer videoTrack list") }
+        }
+        
+        // VIDEO REMOVE_TRACK
+        if let videoRemoveTrackListener = self.videoRemoveTrackListener {
+            player.videoTracks.removeEventListener(type: VideoTrackListEventTypes.REMOVE_TRACK, listener: videoRemoveTrackListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] RemoveTrack listener dettached from THEOplayer videoTrack list") }
+        }
+        
+        // VIDEO CHANGE
+        if let videoChangeTrackListener = self.videoChangeTrackListener {
+            player.videoTracks.removeEventListener(type: VideoTrackListEventTypes.CHANGE, listener: videoChangeTrackListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] ChangeTrack listener dettached from THEOplayer videoTrack list") }
+        }
+    }
+}