react-native-theoplayer 1.8.2 → 2.0.0

package/ios/THEOplayerRCTMainEventHandler.swift

@@ -6,7 +6,7 @@ import THEOplayerSDK
 class THEOplayerRCTMainEventHandler {
     // MARK: Members
     private weak var player: THEOplayer?
-    private var currentPresentationMode = THEOplayerSDK.PresentationMode.inline // TheoPlayer's initial presentationMode
+    private weak var presentationModeContext: THEOplayerRCTPresentationModeContext?
         
     // MARK: Events
     var onNativePlay: RCTDirectEventBlock?
@@ -15,6 +15,7 @@ class THEOplayerRCTMainEventHandler {
     var onNativeLoadStart: RCTDirectEventBlock?
     var onNativeReadyStateChange: RCTDirectEventBlock?
     var onNativeDurationChange: RCTDirectEventBlock?
+    var onNativeVolumeChange: RCTDirectEventBlock?
     var onNativeProgress: RCTBubblingEventBlock?
     var onNativeTimeUpdate: RCTBubblingEventBlock?
     var onNativePlaying: RCTDirectEventBlock?
@@ -24,10 +25,10 @@ class THEOplayerRCTMainEventHandler {
     var onNativeError: RCTDirectEventBlock?
     var onNativeLoadedData: RCTDirectEventBlock?
     var onNativeLoadedMetadata: RCTDirectEventBlock?
-    var onNativeFullscreenPlayerWillPresent: RCTDirectEventBlock?
-    var onNativeFullscreenPlayerDidPresent: RCTDirectEventBlock?
-    var onNativeFullscreenPlayerWillDismiss: RCTDirectEventBlock?
-    var onNativeFullscreenPlayerDidDismiss: RCTDirectEventBlock?
+    var onNativeRateChange: RCTDirectEventBlock?
+    var onNativeWaiting: RCTDirectEventBlock?
+    var onNativeCanPlay: RCTDirectEventBlock?
+    var onNativePresentationModeChange: RCTDirectEventBlock?
     
     // MARK: player Listeners
     private var playListener: EventListener?
@@ -36,6 +37,7 @@ class THEOplayerRCTMainEventHandler {
     private var loadStartListener: EventListener?
     private var readyStateChangeListener: EventListener?
     private var durationChangeListener: EventListener?
+    private var volumeChangeListener: EventListener?
     private var progressListener: EventListener?
     private var timeUpdateListener: EventListener?
     private var playingListener: EventListener?
@@ -45,6 +47,9 @@ class THEOplayerRCTMainEventHandler {
     private var errorListener: EventListener?
     private var loadedDataListener: EventListener?
     private var loadedMetadataListener: EventListener?
+    private var rateChangeListener: EventListener?
+    private var waitingListener: EventListener?
+    private var canPlayListener: EventListener?
     private var presentationModeChangeListener: EventListener?
     
     // MARK: - destruction
@@ -54,23 +59,16 @@ class THEOplayerRCTMainEventHandler {
     }
     
     // MARK: - player setup / breakdown
-    func setPlayer(_ player: THEOplayer) {
-        self.player = player;
+    func setPlayer(_ player: THEOplayer, presentationModeContext: THEOplayerRCTPresentationModeContext) {
+        self.player = player
+        self.presentationModeContext = presentationModeContext
         
         // attach listeners
         self.attachListeners()
     }
     
-    private func attachListeners() {
-        self.attachMainPlayerListeners()
-    }
-    
-    private func dettachListeners() {
-        self.dettachMainPlayerListeners()
-    }
-    
     // MARK: - attach/dettach main player Listeners
-    private func attachMainPlayerListeners() {
+    private func attachListeners() {
         guard let player = self.player else {
             return
         }
@@ -133,25 +131,51 @@ class THEOplayerRCTMainEventHandler {
         }
         if DEBUG_EVENTHANDLER { print("[NATIVE] DurationChange listener attached to THEOplayer") }
         
+        // VOLUME_CHANGE
+        self.volumeChangeListener = player.addEventListener(type: PlayerEventTypes.VOLUME_CHANGE) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received VOLUME_CHANGE event from THEOplayer") }
+            if let forwardedVolumeChangeEvent = self?.onNativeVolumeChange {
+                forwardedVolumeChangeEvent(
+                    [
+                        "volume": event.volume,
+                        "muted": player.muted
+                    ]
+                )
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] VolumeChange listener attached to THEOplayer") }
+        
         // PROGRESS
         self.progressListener = player.addEventListener(type: PlayerEventTypes.PROGRESS) { [weak self] event in
             //if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received PROGRESS event from THEOplayer") }
             if let forwardedProgressEvent = self?.onNativeProgress {
-                player.requestSeekable(completionHandler: { timeRanges, error in
-                    var seekable: [[String:Double]] = []
-                    timeRanges?.forEach({ timeRange in
-                        seekable.append(
+                player.requestSeekable(completionHandler: { seekableTimeRanges, error in
+                    player.requestBuffered(completionHandler: { bufferedTimeRanges, error in
+                        var seekable: [[String:Double]] = []
+                        seekableTimeRanges?.forEach({ timeRange in
+                            seekable.append(
+                                [
+                                    "start": timeRange.start * 1000,            // sec -> msec
+                                    "end": timeRange.end * 1000                 // sec -> msec
+                                ]
+                            )
+                        })
+                        var buffered: [[String:Double]] = []
+                        bufferedTimeRanges?.forEach({ timeRange in
+                            buffered.append(
+                                [
+                                    "start": timeRange.start * 1000,            // sec -> msec
+                                    "end": timeRange.end * 1000                 // sec -> msec
+                                ]
+                            )
+                        })
+                        forwardedProgressEvent(
                             [
-                                "start": timeRange.start * 1000,            // sec -> msec
-                                "end": timeRange.end * 1000                 // sec -> msec
+                                "seekable":seekable,
+                                "buffered":buffered
                             ]
                         )
                     })
-                    forwardedProgressEvent(
-                        [
-                            "seekable":seekable
-                        ]
-                    )
                 })
             }
         }
@@ -249,35 +273,45 @@ class THEOplayerRCTMainEventHandler {
         }
         if DEBUG_EVENTHANDLER { print("[NATIVE] LoadedMetadata listener attached to THEOplayer") }
         
+        // RATE_CHANGE
+        self.rateChangeListener = player.addEventListener(type: PlayerEventTypes.RATE_CHANGE) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received RATE_CHANGE event from THEOplayer") }
+            if let forwardedRateChangeEvent = self?.onNativeRateChange {
+                forwardedRateChangeEvent(["playbackRate": event.playbackRate])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] RateChange listener attached to THEOplayer") }
+        
+        // WAITING
+        self.waitingListener = player.addEventListener(type: PlayerEventTypes.WAITING) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received WAITING event from THEOplayer") }
+            if let forwardedWaitingEvent = self?.onNativeWaiting {
+                forwardedWaitingEvent([:])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] Waiting listener attached to THEOplayer") }
+        
+        // CAN_PLAY
+        self.canPlayListener = player.addEventListener(type: PlayerEventTypes.CAN_PLAY) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received CAN_PLAY event from THEOplayer") }
+            if let forwardedCanPlayEvent = self?.onNativeCanPlay {
+                forwardedCanPlayEvent([:])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] Waiting listener attached to THEOplayer") }
+        
         // PRESENTATION_MODE_CHANGE
         self.presentationModeChangeListener = player.addEventListener(type: PlayerEventTypes.PRESENTATION_MODE_CHANGE) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received PRESENTATION_MODE_CHANGE event from THEOplayer") }
-            if event.presentationMode != self?.currentPresentationMode {
-                // entering fullscreen
-                if event.presentationMode == .fullscreen ,
-                   let forwardedFullscreenPlayerWillPresentEvent = self?.onNativeFullscreenPlayerWillPresent {
-                    forwardedFullscreenPlayerWillPresentEvent([:])
-                }
-                if event.presentationMode == .fullscreen,
-                   let forwardedFullscreenPlayerDidPresentEvent = self?.onNativeFullscreenPlayerDidPresent {
-                    forwardedFullscreenPlayerDidPresentEvent([:])
-                }
-                // exiting fullscreen
-                if self?.currentPresentationMode == .fullscreen,
-                   let forwardedFullscreenPlayerWillDismissEvent = self?.onNativeFullscreenPlayerWillDismiss {
-                    forwardedFullscreenPlayerWillDismissEvent([:])
-                }
-                if self?.currentPresentationMode == .fullscreen,
-                   let forwardedFullscreenPlayerDidDismissEvent = self?.onNativeFullscreenPlayerDidDismiss {
-                    forwardedFullscreenPlayerDidDismissEvent([:])
-                }
-                self?.currentPresentationMode = event.presentationMode
+            if DEBUG_THEOPLAYER_EVENTS || true { print("[NATIVE] Received PRESENTATION_MODE_CHANGE event from THEOplayer (to \(event.presentationMode._rawValue))") }
+            if let forwardedPresentationModeChangeEvent = self?.onNativePresentationModeChange,
+               let presentationModeContext = self?.presentationModeContext {
+                forwardedPresentationModeChangeEvent(presentationModeContext.eventContextForNewPresentationMode(event.presentationMode))
             }
         }
         if DEBUG_EVENTHANDLER { print("[NATIVE] PresentationModeChange listener attached to THEOplayer") }
     }
     
-    private func dettachMainPlayerListeners() {
+    private func dettachListeners() {
         guard let player = self.player else {
             return
         }
@@ -372,6 +406,24 @@ class THEOplayerRCTMainEventHandler {
             if DEBUG_EVENTHANDLER { print("[NATIVE] LoadedMetadata listener dettached from THEOplayer") }
         }
         
+        // RATE_CHANGE
+        if let rateChangeListener = self.rateChangeListener {
+            player.removeEventListener(type: PlayerEventTypes.RATE_CHANGE, listener: rateChangeListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] RateChange listener dettached from THEOplayer") }
+        }
+        
+        // WAITING
+        if let waitingListener = self.waitingListener {
+            player.removeEventListener(type: PlayerEventTypes.WAITING, listener: waitingListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] Waiting listener dettached from THEOplayer") }
+        }
+        
+        // CAN_PLAY
+        if let canPlayListener = self.canPlayListener {
+            player.removeEventListener(type: PlayerEventTypes.CAN_PLAY, listener: canPlayListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] CanPlay listener dettached from THEOplayer") }
+        }
+        
         // PRESENTATION_MODE_CHANGE
         if let presentationModeChangeListener = self.presentationModeChangeListener {
             player.removeEventListener(type: PlayerEventTypes.PRESENTATION_MODE_CHANGE, listener: presentationModeChangeListener)

package/ios/THEOplayerRCTPlayerAPI.swift

@@ -0,0 +1,240 @@
+//
+//  THEOplayerRCTPlayerAPI.swift
+//
+
+import Foundation
+import UIKit
+import THEOplayerSDK
+
+let ERROR_MESSAGE_PLAYER_ABR_UNSUPPORTED_FEATURE: String = "Setting an ABRconfig is not supported on iOS/tvOS."
+let ERROR_MESSAGE_PLAYER_QUALITY_UNSUPPORTED_FEATURE: String = "Setting a target video quality is not supported on iOS/tvOS."
+let ERROR_MESSAGE_PLAYER_FULLSCREEN_UNSUPPORTED_FEATURE: String = "Fullscreen presentationmode should be implemented on the RN level for iOS/tvOS."
+
+@objc(THEOplayerRCTPlayerAPI)
+class THEOplayerRCTPlayerAPI: NSObject, RCTBridgeModule {
+    @objc var bridge: RCTBridge!
+    
+    static func moduleName() -> String! {
+        return "PlayerModule"
+    }
+    
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    @objc(setPaused:paused:)
+    func setPaused(_ node: NSNumber, paused: Bool) -> Void {
+        DispatchQueue.main.async {
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView,
+               let player = theView.player {
+                if paused && !player.paused {
+                    if DEBUG_PLAYER_API { print("[NATIVE] Triggering pause on TheoPlayer") }
+                    player.pause()
+                } else if !paused && player.paused {
+                    if DEBUG_PLAYER_API { print("[NATIVE] Triggering play on TheoPlayer") }
+                    player.play()
+                }
+            }
+        }
+    }
+    
+    @objc(setSource:src:)
+    func setSource(_ node: NSNumber, src: NSDictionary) -> Void {
+        DispatchQueue.main.async {
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView,
+               let srcDescription = THEOplayerRCTSourceDescriptionBuilder.buildSourceDescription(src) {
+                if let player = theView.player {
+                    if DEBUG_PLAYER_API { print("[NATIVE] Setting new source on TheoPlayer") }
+                    player.source = srcDescription
+                }
+            } else {
+                if DEBUG_PLAYER_API { print("[NATIVE] Failed to update THEOplayer source.") }
+            }
+        }
+    }
+    
+    @objc(setABRConfig:abrConfig:)
+    func setABRConfig(_ node: NSNumber, setABRConfig: NSDictionary) -> Void {
+        if DEBUG_PLAYER_API { print(ERROR_MESSAGE_PLAYER_ABR_UNSUPPORTED_FEATURE) }
+        return
+    }
+    
+    @objc(setCurrentTime:time:)
+    func setCurrentTime(_ node: NSNumber, time: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView,
+               let player = theView.player {
+                let timeValue = time.doubleValue * 0.001
+                if DEBUG_PLAYER_API { print("[NATIVE] Seeking to \(timeValue) on TheoPlayer") }
+                player.setCurrentTime(timeValue)
+            }
+        }
+    }
+    
+    @objc(setMuted:muted:)
+    func setMuted(_ node: NSNumber, muted: Bool) -> Void {
+        DispatchQueue.main.async {
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView,
+               let player = theView.player {
+                if player.muted != muted {
+                    if DEBUG_PLAYER_API { print("[NATIVE] Changing TheoPlayer to \(muted ? "muted" : "not muted")") }
+                    player.muted = muted
+                }
+            }
+        }
+    }
+    
+    @objc(setVolume:volume:)
+    func setVolume(_ node: NSNumber, volume: NSNumber) -> Void {
+        if DEBUG_PLAYER_API { print("[NATIVE] Setting volume: TheoPlayer does not handle volume changes for iOS. This is handled by the device.") }
+    }
+    
+    @objc(setPlaybackRate:playbackRate:)
+    func setPlaybackRate(_ node: NSNumber, playbackRate: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView,
+               let player = theView.player {
+                let playbackRateValue = playbackRate.doubleValue
+                if player.playbackRate != playbackRateValue {
+                    if DEBUG_PLAYER_API { print("[NATIVE] Setting playbackRate on TheoPlayer to \(playbackRateValue)") }
+                    player.setPlaybackRate(playbackRateValue)
+                }
+            }
+        }
+    }
+    
+    @objc(setPresentationMode:presentationMode:)
+    func setPresentationMode(_ node: NSNumber, presentationMode: String) -> Void {
+        DispatchQueue.main.async {
+            let newPresentationMode: PresentationMode = THEOplayerRCTTypeUtils.presentationModeFromString(presentationMode)
+            if newPresentationMode == .fullscreen {
+                print(ERROR_MESSAGE_PLAYER_FULLSCREEN_UNSUPPORTED_FEATURE)
+            }
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView,
+               let player = theView.player {
+                if player.presentationMode != newPresentationMode {
+                    if DEBUG_PLAYER_API { print("[NATIVE] Changing TheoPlayer to \(presentationMode)") }
+                    player.presentationMode = newPresentationMode
+                }
+            }
+        }
+        return
+    }
+    
+    @objc(setPipConfig:pipConfig:)
+    func setPipConfig(_ node: NSNumber, pipConfig: NSDictionary) -> Void {
+        DispatchQueue.main.async {
+            let newPipConfig: PipConfig = self.parsePipConfig(configDict: pipConfig)
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView {
+                theView.pipConfig = newPipConfig
+            }
+        }
+        return
+    }
+    
+    private func parsePipConfig(configDict: NSDictionary) -> PipConfig {
+        var pipConfig = PipConfig()
+        pipConfig.retainPresentationModeOnSourceChange = configDict["retainPresentationModeOnSourceChange"] as? Bool ?? false
+        pipConfig.canStartPictureInPictureAutomaticallyFromInline = configDict["startsAutomatically"] as? Bool ?? false
+        return pipConfig
+    }
+    
+    @objc(setBackgroundAudioConfig:backgroundAudioConfig:)
+    func setBackgroundAudioConfig(_ node: NSNumber, backgroundAudioConfig: NSDictionary) -> Void {
+        DispatchQueue.main.async {
+            let newBackgroundAudioConfig: BackgroundAudioConfig = self.parseBackgroundAudioConfig(configDict: backgroundAudioConfig)
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView {
+               theView.backgroundAudioConfig = newBackgroundAudioConfig
+            }
+        }
+        return
+    }
+    
+    private func parseBackgroundAudioConfig(configDict: NSDictionary) -> BackgroundAudioConfig {
+        var backgroundAudio = BackgroundAudioConfig()
+        backgroundAudio.enabled = configDict["enabled"] as? Bool ?? false
+        return backgroundAudio
+    }
+    
+    @objc(setSelectedTextTrack:uid:)
+    func setSelectedTextTrack(_ node: NSNumber, uid: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView,
+               let player = theView.player {
+                let uidValue = uid.intValue
+                let textTracks: TextTrackList = player.textTracks
+                guard textTracks.count > 0 else {
+                    return
+                }
+                if DEBUG_PLAYER_API { print("[NATIVE] Showing textTrack \(uidValue) on TheoPlayer") }
+                for i in 0...textTracks.count-1 {
+                    var textTrack: TextTrack = textTracks.get(i)
+                    if textTrack.uid == uidValue {
+                        textTrack.mode = TextTrackMode.showing
+                    } else if textTrack.mode == TextTrackMode.showing {
+                        textTrack.mode = TextTrackMode.disabled
+                    } 
+                }
+            }
+        }
+    }
+    
+    @objc(setSelectedAudioTrack:uid:)
+    func setSelectedAudioTrack(_ node: NSNumber, uid: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView,
+               let player = theView.player {
+                let uidValue = uid.intValue
+                let audioTracks: AudioTrackList = player.audioTracks
+                guard audioTracks.count > 0 else {
+                    return
+                }
+                if DEBUG_PLAYER_API { print("[NATIVE] Enabling audioTrack \(uidValue) on TheoPlayer") }
+                for i in 0...audioTracks.count-1 {
+                    var audioTrack: MediaTrack = audioTracks.get(i)
+                    audioTrack.enabled = (audioTrack.uid == uidValue)
+                }
+            }
+        }
+    }
+    
+    @objc(setSelectedVideoTrack:uid:)
+    func setSelectedVideoTrack(_ node: NSNumber, uid: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView,
+               let player = theView.player {
+                let uidValue = uid.intValue
+                let videoTracks: VideoTrackList = player.videoTracks
+                guard videoTracks.count > 0 else {
+                    return
+                }
+                if DEBUG_PLAYER_API { print("[NATIVE] Enabling videoTrack \(uidValue) on TheoPlayer") }
+                for i in 0...videoTracks.count-1 {
+                    var videoTrack: MediaTrack = videoTracks.get(i)
+                    videoTrack.enabled = (videoTrack.uid == uidValue)
+                }
+            }
+        }
+    }
+    
+    @objc(setTargetVideoQuality:uid:)
+    func setTargetVideoQuality(_ node: NSNumber, uid: [NSNumber]) -> Void {
+        if DEBUG_PLAYER_API { print(ERROR_MESSAGE_PLAYER_QUALITY_UNSUPPORTED_FEATURE) }
+        return
+    }
+    
+    @objc(setPreload:type:)
+    func setPreload(_ node: NSNumber, type: String) -> Void {
+        DispatchQueue.main.async {
+            if let theView = self.bridge.uiManager.view(forReactTag: node) as? THEOplayerRCTView,
+               let player = theView.player {
+                let preloadType = THEOplayerRCTTypeUtils.preloadTypeFromString(type)
+                if player.preload != preloadType {
+                    if DEBUG_PLAYER_API { print("[NATIVE] Changing TheoPlayer preload type to \(type)") }
+                    player.setPreload(preloadType)
+                }
+            }
+        }
+    }
+    
+}

package/ios/THEOplayerRCTPresentationModeContext.swift

@@ -0,0 +1,29 @@
+// THEOplayerRCTPresentationModeContext.swift
+
+import Foundation
+import THEOplayerSDK
+
+enum PipContext: String {
+    case PIP_CLOSED = "closed"
+    case PIP_RESTORED = "restored"
+}
+
+class THEOplayerRCTPresentationModeContext {
+    // MARK: Members
+    var currentPresentationMode: THEOplayerSDK.PresentationMode = .inline // TheoPlayer's initial presentationMode
+    var pipContext: PipContext = .PIP_CLOSED
+    
+    func eventContextForNewPresentationMode(_ newPresentationMode: PresentationMode) -> [String:Any] {
+        let previousPresentationMode = self.currentPresentationMode
+        self.currentPresentationMode = newPresentationMode
+        
+        var eventContext: [String:Any] = [
+            "presentationMode": THEOplayerRCTTypeUtils.presentationModeToString(self.currentPresentationMode),
+            "previousPresentationMode": THEOplayerRCTTypeUtils.presentationModeToString(previousPresentationMode),
+        ]
+        if previousPresentationMode == .pictureInPicture {
+            eventContext["context"] = ["pip" : self.pipContext.rawValue]
+        }
+        return eventContext
+    }
+}

package/ios/THEOplayerRCTTextTrackEventHandler.swift

@@ -19,6 +19,8 @@ class THEOplayerRCTTextTrackEventHandler {
     // MARK: textTrack listeners (attached dynamically to new texttracks)
     private var addCueListeners: [Int:EventListener] = [:]
     private var removeCueListeners: [Int:EventListener] = [:]
+    private var enterCueListeners: [Int:EventListener] = [:]
+    private var exitCueListeners: [Int:EventListener] = [:]
     
     
     // MARK: - destruction
@@ -57,6 +59,10 @@ class THEOplayerRCTTextTrackEventHandler {
                 if DEBUG_EVENTHANDLER { print("[NATIVE] AddCue listener attached to THEOplayer textTrack with uid \(textTrack.uid)") }
                 welf.removeCueListeners[textTrack.uid] = textTrack.addEventListener(type: TextTrackEventTypes.REMOVE_CUE, listener: welf.removeCueListener(_:))
                 if DEBUG_EVENTHANDLER { print("[NATIVE] RemoveCue listener attached to THEOplayer textTrack with uid \(textTrack.uid)") }
+                welf.enterCueListeners[textTrack.uid] = textTrack.addEventListener(type: TextTrackEventTypes.ENTER_CUE, listener: welf.enterCueListener(_:))
+                if DEBUG_EVENTHANDLER { print("[NATIVE] EnterCue listener attached to THEOplayer textTrack with uid \(textTrack.uid)") }
+                welf.exitCueListeners[textTrack.uid] = textTrack.addEventListener(type: TextTrackEventTypes.EXIT_CUE, listener: welf.exitCueListener(_:))
+                if DEBUG_EVENTHANDLER { print("[NATIVE] ExitCue listener attached to THEOplayer textTrack with uid \(textTrack.uid)") }
             }
         }
         if DEBUG_EVENTHANDLER { print("[NATIVE] AddTrack listener attached to THEOplayer textTrack list") }
@@ -74,11 +80,17 @@ class THEOplayerRCTTextTrackEventHandler {
                 ])
                 // stop listening for cue events on this track
                 if let addCueListener = welf.addCueListeners[textTrack.uid],
-                   let removeCueListener = welf.removeCueListeners[textTrack.uid]{
+                   let removeCueListener = welf.removeCueListeners[textTrack.uid],
+                   let enterCueListener = welf.enterCueListeners[textTrack.uid],
+                   let exitCueListener = welf.exitCueListeners[textTrack.uid] {
                     textTrack.removeEventListener(type: TextTrackEventTypes.ADD_CUE, listener: addCueListener)
                     if DEBUG_EVENTHANDLER { print("[NATIVE] AddCue listener removed from THEOplayer textTrack with uid \(textTrack.uid)") }
                     textTrack.removeEventListener(type: TextTrackEventTypes.REMOVE_CUE, listener: removeCueListener)
                     if DEBUG_EVENTHANDLER { print("[NATIVE] RemoveCue listener removed from THEOplayer textTrack with uid \(textTrack.uid)") }
+                    textTrack.removeEventListener(type: TextTrackEventTypes.ENTER_CUE, listener: enterCueListener)
+                    if DEBUG_EVENTHANDLER { print("[NATIVE] EnterCue listener removed from THEOplayer textTrack with uid \(textTrack.uid)") }
+                    textTrack.removeEventListener(type: TextTrackEventTypes.EXIT_CUE, listener: exitCueListener)
+                    if DEBUG_EVENTHANDLER { print("[NATIVE] ExitCue listener removed from THEOplayer textTrack with uid \(textTrack.uid)") }
                 }
             }
         }
@@ -131,7 +143,7 @@ class THEOplayerRCTTextTrackEventHandler {
             if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received ADD_CUE event from textTrack: trackUid = \(textTrack.uid), cueUid = \(event.cue.uid)") }
             forwardedTextTrackEvent([
                 "trackUid" : textTrack.uid,
-                "type": TrackCueEventType.ADD_CUE,
+                "type": TrackCueEventType.ADD_CUE.rawValue,
                 "cue": THEOplayerRCTTrackMetadataAggregator.aggregatedTextTrackCueInfo(textTrackCue: event.cue)
             ])
         }
@@ -143,7 +155,31 @@ class THEOplayerRCTTextTrackEventHandler {
             if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received REMOVE_CUE event from textTrack: trackUid = \(textTrack.uid), cueUid = \(event.cue.uid)") }
             forwardedTextTrackEvent([
                 "trackUid" : textTrack.uid,
-                "type": TrackCueEventType.REMOVE_CUE,
+                "type": TrackCueEventType.REMOVE_CUE.rawValue,
+                "cue": THEOplayerRCTTrackMetadataAggregator.aggregatedTextTrackCueInfo(textTrackCue: event.cue)
+            ])
+        }
+    }
+    
+    private func enterCueListener(_ event: EnterCueEvent) {
+        if let forwardedTextTrackEvent = self.onNativeTextTrackEvent,
+           let textTrack = event.cue.track {
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received ENTER_CUE event from textTrack: trackUid = \(textTrack.uid), cueUid = \(event.cue.uid)") }
+            forwardedTextTrackEvent([
+                "trackUid" : textTrack.uid,
+                "type": TrackCueEventType.ENTER_CUE.rawValue,
+                "cue": THEOplayerRCTTrackMetadataAggregator.aggregatedTextTrackCueInfo(textTrackCue: event.cue)
+            ])
+        }
+    }
+    
+    private func exitCueListener(_ event: ExitCueEvent) {
+        if let forwardedTextTrackEvent = self.onNativeTextTrackEvent,
+           let textTrack = event.cue.track {
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received EXIT_CUE event from textTrack: trackUid = \(textTrack.uid), cueUid = \(event.cue.uid)") }
+            forwardedTextTrackEvent([
+                "trackUid" : textTrack.uid,
+                "type": TrackCueEventType.EXIT_CUE.rawValue,
                 "cue": THEOplayerRCTTrackMetadataAggregator.aggregatedTextTrackCueInfo(textTrackCue: event.cue)
             ])
         }

package/ios/THEOplayerRCTTrackEventTypes.swift

@@ -14,4 +14,6 @@ enum TrackListEventType: Int {
 enum TrackCueEventType: Int {
     case ADD_CUE = 0
     case REMOVE_CUE = 1
+    case ENTER_CUE = 2
+    case EXIT_CUE = 3
 }

package/ios/THEOplayerRCTTrackMetadataAggregator.swift

@@ -62,7 +62,7 @@ class THEOplayerRCTTrackMetadataAggregator {
         entry[PROP_UID] = textTrack.uid
         entry[PROP_KIND] = textTrack.kind
         entry[PROP_LANGUAGE] = textTrack.language
-        entry[PROP_MODE] = String(describing: textTrack.mode)
+        entry[PROP_MODE] = textTrack.mode._rawValue
         entry[PROP_LABEL] = textTrack.label
         entry[PROP_TYPE] = textTrack.type
         entry[PROP_SRC] = textTrack.src
@@ -97,7 +97,11 @@ class THEOplayerRCTTrackMetadataAggregator {
         entry[PROP_UID] = textTrackCue.uid
         entry[PROP_STARTTIME] = (textTrackCue.startTime ?? 0) * 1000
         entry[PROP_ENDTIME] = (textTrackCue.endTime ?? 0) * 1000
-        entry[PROP_CUE_CONTENT] = textTrackCue.contentString
+        if let content = textTrackCue.content {
+            entry[PROP_CUE_CONTENT] = content
+        } else if let contentString = textTrackCue.contentString {
+            entry[PROP_CUE_CONTENT] = contentString
+        }
         return entry
     }
 
@@ -108,14 +112,13 @@ class THEOplayerRCTTrackMetadataAggregator {
             return audioTrackEntries
         }
         for i in 0...audioTracks.count-1 {
-            if let audioTrack: AudioTrack = audioTracks.get(i) as? AudioTrack {
-                audioTrackEntries.append(THEOplayerRCTTrackMetadataAggregator.aggregatedAudioTrackInfo(audioTrack: audioTrack))
-            }
+            let audioTrack: MediaTrack = audioTracks.get(i) // should be casted to AudioTrack
+            audioTrackEntries.append(THEOplayerRCTTrackMetadataAggregator.aggregatedAudioTrackInfo(audioTrack: audioTrack))
         }
         return audioTrackEntries
     }
     
-    class func aggregatedAudioTrackInfo(audioTrack: AudioTrack) -> [String:Any] {
+    class func aggregatedAudioTrackInfo(audioTrack: MediaTrack) -> [String:Any] {
         var entry: [String:Any] = [:]
         entry[PROP_ID] = audioTrack.id
         entry[PROP_UID] = audioTrack.uid