react-native-theoplayer 1.6.1 → 1.7.1

package/ios/THEOplayerRCTView.swift

@@ -7,13 +7,18 @@ import THEOplayerSDK
 class THEOplayerRCTView: UIView {
     // MARK: Members
     private var player: THEOplayer?
-    private var eventHandler: THEOplayerRCTViewEventHandler
+    private var mainEventHandler: THEOplayerRCTViewMainEventHandler
+    private var textTrackEventHandler: THEOplayerRCTViewTextTrackEventHandler
+    private var adEventHandler: THEOplayerRCTViewAdEventHandler
     
     // 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
@@ -26,19 +31,30 @@ class THEOplayerRCTView: UIView {
     
     // MARK: - Initialisation / view setup
     init() {
-        // create an event handler to contain event props
-        self.eventHandler = THEOplayerRCTViewEventHandler()
+        // create event handlers to maintain event props
+        self.mainEventHandler = THEOplayerRCTViewMainEventHandler()
+        self.textTrackEventHandler = THEOplayerRCTViewTextTrackEventHandler()
+        self.adEventHandler = THEOplayerRCTViewAdEventHandler()
         
         super.init(frame: .zero)
     }
     
     func destroy() {
-        self.eventHandler.destroy()
+        self.mainEventHandler.destroy()
+        self.textTrackEventHandler.destroy()
+        self.adEventHandler.destroy()
         self.player?.destroy()
         self.player = nil
         if DEBUG_THEOPLAYER_INTERACTION { print("[NATIVE] THEOplayer instance destroyed.") }
     }
     
+    func ads() -> Ads? {
+        guard let player = self.player else {
+            return nil
+        }
+        return player.ads
+    }
+    
     required init?(coder aDecoder: NSCoder) {
         fatalError("[NATIVE] init(coder:) has not been implemented")
     }
@@ -79,32 +95,56 @@ class THEOplayerRCTView: UIView {
             return
         }
         
-        if (self.player == nil) {
-            // 'lazy' init THEOplayer instance, performed on next runloop, to make sure all props have been set (license config is needed to init player)
-            DispatchQueue.main.async {
-                if DEBUG_THEOPLAYER_INTERACTION { print("[NATIVE] 'lazy' init THEOplayer instance") }
+        // reset player for new source
+        if 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)
+            }
+            self.syncAllPlayerProps()
+        }
+    }
+    
+    private func initPlayer() {
+        if DEBUG_THEOPLAYER_INTERACTION { print("[NATIVE] 'lazy' init THEOplayer instance") }
 #if os(tvOS)
-                self.player = THEOplayer(configuration: THEOplayerConfiguration(chromeless: self.chromeless, license: self.license, licenseUrl: self.licenseUrl, pip: nil))
+        self.player = THEOplayer(configuration: THEOplayerConfiguration(chromeless: self.chromeless,
+                                                                        license: self.license,
+                                                                        licenseUrl: self.licenseUrl,
+                                                                        pip: nil))
 #else
-                let stylePath = Bundle.main.path(forResource:"style", ofType: "css")
-                let cssPaths = stylePath != nil ? [stylePath!] : []
-                self.player = THEOplayer(configuration: THEOplayerConfiguration(chromeless: self.chromeless, cssPaths: cssPaths, pip: nil, license: self.license, licenseUrl: self.licenseUrl))
+        let stylePath = Bundle.main.path(forResource:"style", ofType: "css")
+        let cssPaths = stylePath != nil ? [stylePath!] : []
+        self.player = THEOplayer(configuration: THEOplayerConfiguration(chromeless: self.chromeless,
+                                                                        cssPaths: cssPaths,
+                                                                        pip: nil,
+                                                                        ads: self.initAdsConfiguration(),
+                                                                        license: self.license,
+                                                                        licenseUrl: self.licenseUrl))
 #endif
-                if let player = self.player {
-                    // couple player instance to event handler
-                    self.eventHandler.setPlayer(player)
-                    // couple player instance to view
-                    player.addAsSubview(of: self)
-                }
-                self.syncAllPlayerProps()
-            }
-        } else {
-            self.syncPlayerSrc()
-            self.syncPlayerMuted()
-            if !self.paused {
-                self.player?.play()
-            }
-        }
+    }
+    
+    private func initAdsConfiguration() -> AdsConfiguration? {
+#if ADS && (GOOGLE_IMA || GOOGLE_DAI)
+        let googleIMAConfiguration = GoogleIMAConfiguration()
+        googleIMAConfiguration.useNativeIma = self.googleImaUsesNativeIma
+        googleIMAConfiguration.disableUI = !self.adSUIEnabled
+        return AdsConfiguration(showCountdown: self.adSUIEnabled,
+                                preload: self.adPreloadType,
+                                googleImaConfiguration: googleIMAConfiguration)
+#else
+        return nil
+#endif
+        
     }
     
     private func syncPlayerSrc() {
@@ -121,6 +161,15 @@ class THEOplayerRCTView: UIView {
         self.license = configDict["license"] as? String
         self.licenseUrl = configDict["licenseUrl"] as? String
         self.chromeless = configDict["chromeless"] as? Bool ?? true
+        if let adsConfig = configDict["ads"] as? NSDictionary {
+            self.adSUIEnabled = adsConfig["uiEnabled"] as? Bool ?? true
+            if let adPreloadType = adsConfig["preload"] as? String {
+                self.adPreloadType = adPreloadType == "none" ? THEOplayerSDK.AdPreloadType.NONE : THEOplayerSDK.AdPreloadType.MIDROLL_AND_POSTROLL
+            }
+            if let googleImaConfiguration = adsConfig["googleImaConfiguration"] as? NSDictionary {
+                self.googleImaUsesNativeIma = googleImaConfiguration["useNativeIma"] as? Bool ?? true
+            }
+        }
         if DEBUG_PROP_UPDATES  { print("[NATIVE] config prop updated.") }
     }
     
@@ -296,130 +345,141 @@ class THEOplayerRCTView: UIView {
         }
     }
     
-    // MARK: - Listener based event bridging
+    // MARK: - Listener based MAIN event bridging
+    
     @objc(setOnNativePlay:)
     func setOnNativePlay(nativePlay: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativePlay = nativePlay
+        self.mainEventHandler.onNativePlay = nativePlay
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativePlay prop set.") }
     }
     
     @objc(setOnNativePause:)
     func setOnNativePause(nativePause: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativePause = nativePause
+        self.mainEventHandler.onNativePause = nativePause
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativePause prop set.") }
     }
     
     @objc(setOnNativeSourceChange:)
     func setOnNativeSourceChange(nativeSourceChange: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeSourceChange = nativeSourceChange
+        self.mainEventHandler.onNativeSourceChange = nativeSourceChange
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeSourceChange prop set.") }
     }
     
     @objc(setOnNativeLoadStart:)
     func setOnNativeLoadStart(nativeLoadStart: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeLoadStart = nativeLoadStart
+        self.mainEventHandler.onNativeLoadStart = nativeLoadStart
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeLoadStart prop set.") }
     }
     
     @objc(setOnNativeReadyStateChange:)
     func setOnNativeReadyStateChange(nativeReadyStateChange: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeReadyStateChange = nativeReadyStateChange
+        self.mainEventHandler.onNativeReadyStateChange = nativeReadyStateChange
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeReadyStateChange prop set.") }
     }
     
     @objc(setOnNativeDurationChange:)
     func setOnNativeDurationChange(nativeDurationChange: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeDurationChange = nativeDurationChange
+        self.mainEventHandler.onNativeDurationChange = nativeDurationChange
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeDurationChange prop set.") }
     }
     
     @objc(setOnNativeProgress:)
     func setOnNativeProgress(nativeProgress: @escaping RCTBubblingEventBlock) {
-        self.eventHandler.onNativeProgress = nativeProgress
+        self.mainEventHandler.onNativeProgress = nativeProgress
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeProgress prop set.") }
     }
     
     @objc(setOnNativeTimeUpdate:)
     func setOnNativeTimeUpdate(nativeTimeUpdate: @escaping RCTBubblingEventBlock) {
-        self.eventHandler.onNativeTimeUpdate = nativeTimeUpdate
+        self.mainEventHandler.onNativeTimeUpdate = nativeTimeUpdate
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeTimeUpdate prop set.") }
     }
     
     @objc(setOnNativePlaying:)
     func setOnNativePlaying(nativePlaying: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativePlaying = nativePlaying
+        self.mainEventHandler.onNativePlaying = nativePlaying
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativePlaying prop set.") }
     }
     
     @objc(setOnNativeSeeking:)
     func setOnNativeSeeking(nativeSeeking: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeSeeking = nativeSeeking
+        self.mainEventHandler.onNativeSeeking = nativeSeeking
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeSeeking prop set.") }
     }
     
     @objc(setOnNativeSeeked:)
     func setOnNativeSeeked(nativeSeeked: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeSeeked = nativeSeeked
+        self.mainEventHandler.onNativeSeeked = nativeSeeked
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeSeeked prop set.") }
     }
     
     @objc(setOnNativeEnded:)
     func setOnNativeEnded(nativeEnded: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeEnded = nativeEnded
+        self.mainEventHandler.onNativeEnded = nativeEnded
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeEnded prop set.") }
     }
     
     @objc(setOnNativeError:)
     func setOnNativeError(nativeError: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeError = nativeError
+        self.mainEventHandler.onNativeError = nativeError
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeError prop set.") }
     }
     
     @objc(setOnNativeLoadedData:)
     func setOnNativeLoadedData(nativeLoadedData: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeLoadedData = nativeLoadedData
+        self.mainEventHandler.onNativeLoadedData = nativeLoadedData
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeLoadedData prop set.") }
     }
     
     @objc(setOnNativeLoadedMetadata:)
     func setOnNativeLoadedMetadata(nativeLoadedMetadata: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeLoadedMetadata = nativeLoadedMetadata
+        self.mainEventHandler.onNativeLoadedMetadata = nativeLoadedMetadata
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeLoadedMetadata prop set.") }
     }
     
     @objc(setOnNativeFullscreenPlayerWillPresent:)
     func setOnNativeFullscreenPlayerWillPresent(nativeFullscreenPlayerWillPresent: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeFullscreenPlayerWillPresent = nativeFullscreenPlayerWillPresent
+        self.mainEventHandler.onNativeFullscreenPlayerWillPresent = nativeFullscreenPlayerWillPresent
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeFullscreenPlayerWillPresent prop set.") }
     }
     
     @objc(setOnNativeFullscreenPlayerDidPresent:)
     func setOnNativeFullscreenPlayerDidPresent(nativeFullscreenPlayerDidPresent: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeFullscreenPlayerDidPresent = nativeFullscreenPlayerDidPresent
+        self.mainEventHandler.onNativeFullscreenPlayerDidPresent = nativeFullscreenPlayerDidPresent
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeFullscreenPlayerDidPresent prop set.") }
     }
 
     @objc(setOnNativeFullscreenPlayerWillDismiss:)
     func setOnNativeFullscreenPlayerWillDismiss(nativeFullscreenPlayerWillDismiss: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeFullscreenPlayerWillDismiss = nativeFullscreenPlayerWillDismiss
+        self.mainEventHandler.onNativeFullscreenPlayerWillDismiss = nativeFullscreenPlayerWillDismiss
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeFullscreenPlayerWillDismiss prop set.") }
     }
     
     @objc(setOnNativeFullscreenPlayerDidDismiss:)
     func setOnNativeFullscreenPlayerDidDismiss(nativeFullscreenPlayerDidDismiss: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeFullscreenPlayerDidDismiss = nativeFullscreenPlayerDidDismiss
+        self.mainEventHandler.onNativeFullscreenPlayerDidDismiss = nativeFullscreenPlayerDidDismiss
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeFullscreenPlayerDidDismiss prop set.") }
     }
     
+    // MARK: - Listener based TEXTTRACK event bridging
+    
     @objc(setOnNativeTextTrackListEvent:)
     func setOnNativeTextTrackListEvent(nativeTextTrackListEvent: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeTextTrackListEvent = nativeTextTrackListEvent
+        self.textTrackEventHandler.onNativeTextTrackListEvent = nativeTextTrackListEvent
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeTextTrackListEvent prop set.") }
     }
     
     @objc(setOnNativeTextTrackEvent:)
     func setOnNativeTextTrackEvent(nativeTextTrackEvent: @escaping RCTDirectEventBlock) {
-        self.eventHandler.onNativeTextTrackEvent = nativeTextTrackEvent
+        self.textTrackEventHandler.onNativeTextTrackEvent = nativeTextTrackEvent
         if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeTextTrackEvent prop set.") }
     }
+    
+    // MARK: - Listener based AD event bridging
+    
+    @objc(setOnNativeAdEvent:)
+    func setOnNativeAdEvent(nativeAdEvent: @escaping RCTDirectEventBlock) {
+        self.adEventHandler.onNativeAdEvent = nativeAdEvent
+        if DEBUG_PROP_UPDATES  { print("[NATIVE] nativeAdEvent prop set.") }
+    }
 }

package/ios/THEOplayerRCTViewAdEventHandler.swift

@@ -0,0 +1,238 @@
+// THEOplayerRCTViewAdEventHandler.swift
+
+import Foundation
+import THEOplayerSDK
+
+let AD_EVENT_PROP_TYPE: String = "type"
+let AD_EVENT_PROP_AD: String = "ad"
+
+let EVENT_TYPE_AD_BEGIN: String = "adbegin"
+let EVENT_TYPE_AD_END: String = "adend"
+let EVENT_TYPE_ADBREAK_BEGIN: String = "adbreakbegin"
+let EVENT_TYPE_ADBREAK_END: String = "adbreakend"
+let EVENT_TYPE_AD_ERROR: String = "aderror"
+let EVENT_TYPE_AD_FIRST_QUARTILE: String = "adfirstquartile"
+let EVENT_TYPE_AD_THIRD_QUARTILE: String = "adthirdquartile"
+let EVENT_TYPE_AD_MIDPOINT: String = "admidpoint"
+let EVENT_TYPE_AD_LOADED: String = "adloaded"
+
+class THEOplayerRCTViewAdEventHandler {
+    // MARK: Members
+    private weak var player: THEOplayer?
+        
+    // MARK: Events
+    var onNativeAdEvent: RCTDirectEventBlock?
+    
+    // MARK: Ad Listeners
+    private var adBeginListener: EventListener?
+    private var adEndListener: EventListener?
+    private var adBreakBeginListener: EventListener?
+    private var adBreakEndListener: EventListener?
+    private var adErrorListener: EventListener?
+    private var adFirstQuartileListener: EventListener?
+    private var adMidpointListener: EventListener?
+    private var adThirdQuartileListener: EventListener?
+    private var adLoadedListener: EventListener?
+    
+    // MARK: - destruction
+    func destroy() {
+        // dettach listeners
+#if ADS && (GOOGLE_IMA || GOOLGE_DAI)
+        self.dettachListeners()
+#endif
+    }
+    
+    // MARK: - player setup / breakdown
+    func setPlayer(_ player: THEOplayer) {
+        self.player = player;
+        
+        // attach listeners
+#if ADS && (GOOGLE_IMA || GOOLGE_DAI)
+        self.attachListeners()
+#endif
+    }
+    
+    // MARK: - attach/dettach Listeners
+    private func attachListeners() {
+        guard let player = self.player else {
+            return
+        }
+
+        // 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") }
+            if let forwardedAdEvent = self?.onNativeAdEvent,
+               let ad = event.ad {
+                forwardedAdEvent([
+                    AD_EVENT_PROP_TYPE: EVENT_TYPE_AD_BEGIN,
+                    AD_EVENT_PROP_AD: THEOplayerRCTAdAggregator.aggregateAd(ad: ad)
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AdBegin listener attached to THEOplayer.ads") }
+        
+        // AD_END
+        self.adEndListener = player.ads.addEventListener(type: AdsEventTypes.AD_END) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_END event from THEOplayer Ads") }
+            if let forwardedAdEvent = self?.onNativeAdEvent,
+               let ad = event.ad {
+                forwardedAdEvent([
+                    AD_EVENT_PROP_TYPE: EVENT_TYPE_AD_END,
+                    AD_EVENT_PROP_AD: THEOplayerRCTAdAggregator.aggregateAd(ad: ad)
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AdEnd listener attached to THEOplayer.ads") }
+        
+        // AD_BREAK_BEGIN
+        self.adBreakBeginListener = player.ads.addEventListener(type: AdsEventTypes.AD_BREAK_BEGIN) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_BREAK_BEGIN event from THEOplayer Ads") }
+            if let forwardedAdEvent = self?.onNativeAdEvent,
+               let adBreak = event.ad {
+                forwardedAdEvent([
+                    AD_EVENT_PROP_TYPE: EVENT_TYPE_ADBREAK_BEGIN,
+                    AD_EVENT_PROP_AD: THEOplayerRCTAdAggregator.aggregateAdBreak(adBreak: adBreak)
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AdBreakBegin listener attached to THEOplayer.ads") }
+        
+        // AD_BREAK_END
+        self.adBreakEndListener = player.ads.addEventListener(type: AdsEventTypes.AD_BREAK_END) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_BREAK_END event from THEOplayer Ads") }
+            if let forwardedAdEvent = self?.onNativeAdEvent,
+               let adBreak = event.ad {
+                forwardedAdEvent([
+                    AD_EVENT_PROP_TYPE: EVENT_TYPE_ADBREAK_END,
+                    AD_EVENT_PROP_AD: THEOplayerRCTAdAggregator.aggregateAdBreak(adBreak: adBreak)
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AdBreakEnd listener attached to THEOplayer.ads") }
+        
+        // AD_ERROR
+        self.adErrorListener = player.ads.addEventListener(type: AdsEventTypes.AD_ERROR) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_ERROR event from THEOplayer Ads") }
+            if let forwardedAdEvent = self?.onNativeAdEvent,
+               let ad = event.ad {
+                forwardedAdEvent([
+                    AD_EVENT_PROP_TYPE: EVENT_TYPE_AD_ERROR,
+                    AD_EVENT_PROP_AD: THEOplayerRCTAdAggregator.aggregateAd(ad: ad)
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AdError listener attached to THEOplayer.ads") }
+        
+        // AD_FIRST_QUARTILE
+        self.adFirstQuartileListener = player.ads.addEventListener(type: AdsEventTypes.AD_FIRST_QUARTILE) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_FIRST_QUARTILE event from THEOplayer Ads") }
+            if let forwardedAdEvent = self?.onNativeAdEvent,
+               let ad = event.ad {
+                forwardedAdEvent([
+                    AD_EVENT_PROP_TYPE: EVENT_TYPE_AD_FIRST_QUARTILE,
+                    AD_EVENT_PROP_AD: THEOplayerRCTAdAggregator.aggregateAd(ad: ad)
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AdFirstQuartile listener attached to THEOplayer.ads") }
+    
+        // AD_MIDPOINT
+        self.adMidpointListener = player.ads.addEventListener(type: AdsEventTypes.AD_MIDPOINT) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_MIDPOINT event from THEOplayer Ads") }
+            if let forwardedAdEvent = self?.onNativeAdEvent,
+               let ad = event.ad {
+                forwardedAdEvent([
+                    AD_EVENT_PROP_TYPE: EVENT_TYPE_AD_MIDPOINT,
+                    AD_EVENT_PROP_AD: THEOplayerRCTAdAggregator.aggregateAd(ad: ad)
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AdMidpoint listener attached to THEOplayer.ads") }
+    
+        // AD_THIRD_QUARTILE
+        self.adThirdQuartileListener = player.ads.addEventListener(type: AdsEventTypes.AD_THIRD_QUARTILE) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_THIRD_QUARTILE event from THEOplayer Ads") }
+            if let forwardedAdEvent = self?.onNativeAdEvent,
+               let ad = event.ad {
+                forwardedAdEvent([
+                    AD_EVENT_PROP_TYPE: EVENT_TYPE_AD_THIRD_QUARTILE,
+                    AD_EVENT_PROP_AD: THEOplayerRCTAdAggregator.aggregateAd(ad: ad)
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AdThirdQuartile listener attached to THEOplayer.ads") }
+    
+        // AD_LOADED
+        self.adLoadedListener = player.ads.addEventListener(type: AdsEventTypes.AD_LOADED) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_LOADED event from THEOplayer Ads") }
+            if let forwardedAdEvent = self?.onNativeAdEvent,
+               let ad = event.ad {
+                forwardedAdEvent([
+                    AD_EVENT_PROP_TYPE: EVENT_TYPE_AD_LOADED,
+                    AD_EVENT_PROP_AD: THEOplayerRCTAdAggregator.aggregateAd(ad: ad)
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { print("[NATIVE] AdThirdQuartile listener attached to THEOplayer.ads") }
+    }
+    
+    private func dettachListeners() {
+        guard let player = self.player else {
+            return
+        }
+        
+        // AD_BEGIN
+        if let adBeginListener = self.adBeginListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_BEGIN, listener: adBeginListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] AdBegin listener dettached from THEOplayer.ads") }
+        }
+        
+        // AD_END
+        if let adEndListener = self.adEndListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_END, listener: adEndListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] AdEnd listener dettached from THEOplayer.ads") }
+        }
+        
+        // AD_BREAK_BEGIN
+        if let adBreakBeginListener = self.adBreakBeginListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_BREAK_BEGIN, listener: adBreakBeginListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] AdBreakBegin listener dettached from THEOplayer.ads") }
+        }
+        
+        // AD_BREAK_END
+        if let adBreakEndListener = self.adBreakEndListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_BREAK_END, listener: adBreakEndListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] AdBreakEnd listener dettached from THEOplayer.ads") }
+        }
+        
+        // AD_ERROR
+        if let adErrorListener = self.adErrorListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_ERROR, listener: adErrorListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] AdError listener dettached from THEOplayer.ads") }
+        }
+        
+        // AD_FIRST_QUARTILE
+        if let adFirstQuartileListener = self.adFirstQuartileListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_FIRST_QUARTILE, listener: adFirstQuartileListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] adFirstQuartileListener listener dettached from THEOplayer.ads") }
+        }
+        
+        // AD_MIDPOINT
+        if let adMidpointListener = self.adMidpointListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_MIDPOINT, listener: adMidpointListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] adMidpointListener listener dettached from THEOplayer.ads") }
+        }
+        
+        // AD_THIRD_QUARTILE
+        if let adThirdQuartileListener = self.adThirdQuartileListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_THIRD_QUARTILE, listener: adThirdQuartileListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] adThirdQuartileListener listener dettached from THEOplayer.ads") }
+        }
+        
+        // AD_LOADED
+        if let adLoadedListener = self.adLoadedListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_LOADED, listener: adLoadedListener)
+            if DEBUG_EVENTHANDLER { print("[NATIVE] adLoadedListener listener dettached from THEOplayer.ads") }
+        }
+    }
+}