react-native-theoplayer 9.7.1 → 9.9.0

package/CHANGELOG.md

@@ -5,7 +5,31 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.1.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## [9.7.1]
+## [9.9.0] - 25-07-14
+
+### Added
+
+- Added initializationDelay to TheoAdsDecription, to delay THEOads session creation for more optimal ads monetisation.
+
+### Fixed
+
+- Fixed an issue on iOS where on iPads the fullscreen dimensions were not correctly updated after the first device orientation change.
+
+## [9.8.0] - 25-07-08
+
+### Changed
+
+- Deprecated the `BaseSource.integration` property in favor of `TypedSource.type`.
+
+## Added
+
+- Added support for `THEOlive` events.
+
+## Fixed
+
+- Fixed an issue on Android where, depending on the project structure, the Maven repository list would be incorrect.
+
+## [9.7.1] - 25-07-03
 
 ### Fixed
 

package/android/build.gradle

@@ -118,10 +118,14 @@ rootProject.allprojects {
 repositories {
     google()
     mavenCentral()
+    maven { url "https://maven.theoplayer.com/releases" }
+    maven { url "https://maven.theoplayer.com/snapshots" }
+    maven { url("$rootDir/../node_modules/react-native-theoplayer/android/local") }
+    mavenLocal()
 }
 
-// The minimum supported THEOplayer version is 9.7.0
-def theoVersion = safeExtGet('THEOplayer_sdk', '[9.7.0, 10.0.0)')
+// The minimum supported THEOplayer version is 9.8.0
+def theoVersion = safeExtGet('THEOplayer_sdk', '[9.8.0, 10.0.0)')
 def theoMediaSessionVersion = safeExtGet('THEOplayer_mediasession', '[8.0.0, 10.0.0)')
 def theoAdsWrapperVersion = "9.0.0"
 def coroutinesVersion = safeExtGet('coroutinesVersion', '1.7.3')

package/android/src/main/java/com/theoplayer/PlayerEventEmitter.kt

@@ -43,6 +43,7 @@ import com.theoplayer.android.api.player.track.texttrack.TextTrackKind
 import com.theoplayer.android.api.player.track.texttrack.TextTrackMode
 import com.theoplayer.cast.CastEventAdapter
 import com.theoplayer.presentation.PresentationModeChangeContext
+import com.theoplayer.theolive.THEOliveEventAdapter
 import com.theoplayer.track.*
 import com.theoplayer.util.PayloadBuilder
 import kotlin.math.floor
@@ -75,6 +76,7 @@ private const val EVENT_MEDIATRACK_LIST_EVENT = "onNativeMediaTrackListEvent"
 private const val EVENT_MEDIATRACK_EVENT = "onNativeMediaTrackEvent"
 private const val EVENT_AD_EVENT = "onNativeAdEvent"
 private const val EVENT_CAST_EVENT = "onNativeCastEvent"
+private const val EVENT_THEOLIVE_EVENT = "onNativeTHEOliveEvent"
 private const val EVENT_PRESENTATIONMODECHANGE = "onNativePresentationModeChange"
 private const val EVENT_VOLUMECHANGE = "onNativeVolumeChange"
 private const val EVENT_RESIZE = "onNativeResize"
@@ -117,6 +119,7 @@ class PlayerEventEmitter internal constructor(
     EVENT_MEDIATRACK_EVENT,
     EVENT_AD_EVENT,
     EVENT_CAST_EVENT,
+    EVENT_THEOLIVE_EVENT,
     EVENT_PRESENTATIONMODECHANGE,
     EVENT_VOLUMECHANGE,
     EVENT_RESIZE
@@ -151,6 +154,7 @@ class PlayerEventEmitter internal constructor(
       EVENT_MEDIATRACK_EVENT,
       EVENT_AD_EVENT,
       EVENT_CAST_EVENT,
+      EVENT_THEOLIVE_EVENT,
       EVENT_PRESENTATIONMODECHANGE,
       EVENT_VOLUMECHANGE,
       EVENT_RESIZE
@@ -164,6 +168,7 @@ class PlayerEventEmitter internal constructor(
   private val videoTrackListeners = HashMap<EventType<*>, EventListener<*>>()
   private var adEventAdapter: AdEventAdapter? = null
   private var castEventAdapter: CastEventAdapter? = null
+  private var theoLiveEventAdapter: THEOliveEventAdapter? = null
   private var lastTimeUpdate: Long = 0
   private var lastCurrentTime = 0.0
   private var resizeListener = View.OnLayoutChangeListener { v, _, _, _, _, oldLeft, oldTop, oldRight, oldBottom ->
@@ -672,6 +677,12 @@ class PlayerEventEmitter internal constructor(
       }
     }
 
+    theoLiveEventAdapter = THEOliveEventAdapter(player.theoLive, object : THEOliveEventAdapter.Emitter {
+      override fun emit(payload: WritableMap?) {
+        receiveEvent(EVENT_THEOLIVE_EVENT, payload)
+      }
+    })
+
     // Attach view size listener
     playerView.addOnLayoutChangeListener(resizeListener)
   }
@@ -714,5 +725,6 @@ class PlayerEventEmitter internal constructor(
 
     castEventAdapter?.destroy()
     adEventAdapter?.destroy()
+    theoLiveEventAdapter?.destroy()
   }
 }

package/android/src/main/java/com/theoplayer/source/SourceAdapter.kt

@@ -67,6 +67,7 @@ private const val PROP_OVERRIDE_LAYOUT = "overrideLayout"
 private const val PROP_NETWORK_CODE = "networkCode"
 private const val PROP_USE_ID3 = "useId3"
 private const val PROP_RETRIEVE_POD_ID_URI = "retrievePodIdURI"
+private const val PROP_INITIALIZATION_DELAY = "initializationDelay"
 private const val PROP_SSE_ENDPOINT = "sseEndpoint"
 private const val PROP_LATENCY_CONFIGURATION = "latencyConfiguration"
 private const val PROP_PLAYBACK_PIPELINE = "playbackPipeline"
@@ -78,7 +79,7 @@ private const val ERROR_MISSING_CSAI_INTEGRATION = "Missing CSAI integration"
 
 private const val PROP_SSAI_INTEGRATION_GOOGLE_DAI = "google-dai"
 
-private const val INTEGRATION_THEOLIVE = "theolive"
+private const val TYPE_THEOLIVE = "theolive"
 private const val TYPE_MILLICAST = "millicast"
 private const val PLAYBACK_PIPELINE_LEGACY = "legacy"
 
@@ -184,10 +185,14 @@ class SourceAdapter {
 
   @Throws(THEOplayerException::class)
   private fun parseTypedSource(jsonTypedSource: JSONObject, cmcdTransmissionMode: CMCDTransmissionMode? = null): TypedSource {
-    // Some integrations do not support the Builder pattern
+    // Property `integration` will be replaced with `type`.
+    val integration = jsonTypedSource.optString(PROP_INTEGRATION)
+    val type = jsonTypedSource.optString(PROP_TYPE)
+
+    // Note: Some integrations do not support the Builder pattern
     return when {
-      (jsonTypedSource.optString(PROP_INTEGRATION)) == INTEGRATION_THEOLIVE -> parseTheoLiveSource(jsonTypedSource)
-      (jsonTypedSource.optString(PROP_TYPE)) == TYPE_MILLICAST -> parseMillicastSource(jsonTypedSource)
+      type == TYPE_THEOLIVE || integration == TYPE_THEOLIVE -> parseTheoLiveSource(jsonTypedSource)
+      type == TYPE_MILLICAST -> parseMillicastSource(jsonTypedSource)
       else -> parseTypedSourceFromBuilder(jsonTypedSource, cmcdTransmissionMode)
     }
   }
@@ -361,6 +366,7 @@ class SourceAdapter {
       overrideLayout = parseOverrideLayout(jsonAdDescription.optString(PROP_OVERRIDE_LAYOUT)),
       useId3 = jsonAdDescription.optBoolean(PROP_USE_ID3, false),
       retrievePodIdURI = jsonAdDescription.optString(PROP_RETRIEVE_POD_ID_URI).takeIf { it.isNotEmpty() },
+      initializationDelay = jsonAdDescription.optDouble(PROP_INITIALIZATION_DELAY),
       sseEndpoint = jsonAdDescription.optString(PROP_SSE_ENDPOINT).takeIf { it.isNotEmpty() },
     )
   }

package/android/src/main/java/com/theoplayer/theolive/EndpointAdapter.kt

@@ -0,0 +1,68 @@
+package com.theoplayer.theolive
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.theoplayer.android.api.theolive.ContentProtectionConfiguration
+import com.theoplayer.android.api.theolive.Endpoint
+import com.theoplayer.android.api.theolive.FairPlayConfiguration
+import com.theoplayer.android.api.theolive.KeySystemConfiguration
+
+private const val PROP_HESP_SRC = "hespSrc"
+private const val PROP_HLS_SRC = "hlsSrc"
+private const val PROP_AD_SRC = "adSrc"
+private const val PROP_TARGET_LATENCY = "targetLatency"
+private const val PROP_WEIGHT = "weight"
+private const val PROP_PRIORITY = "priority"
+private const val PROP_CONTENT_PROTECTION = "contentProtection"
+private const val PROP_INTEGRATION = "integration"
+
+private const val PROP_WIDEVINE = "widevine"
+private const val PROP_PLAYREADY = "playready"
+private const val PROP_FAIRPLAY = "fairplay"
+private const val PROP_LICENSE_URL = "licenseUrl"
+private const val PROP_CERTIFICATE_URL = "certificateUrl"
+
+object EndpointAdapter {
+
+  fun fromEndpoint(endPoint: Endpoint): WritableMap {
+    return Arguments.createMap().apply {
+      endPoint.hespSrc?.let { putString(PROP_HESP_SRC, it) }
+      endPoint.hlsSrc?.let { putString(PROP_HLS_SRC, it) }
+      endPoint.adSrc?.let { putString(PROP_AD_SRC, it) }
+      endPoint.targetLatency?.let { putDouble(PROP_TARGET_LATENCY, it) }
+      putInt(PROP_WEIGHT, endPoint.weight)
+      putInt(PROP_PRIORITY, endPoint.priority)
+      endPoint.contentProtection?.let {
+        putMap(PROP_CONTENT_PROTECTION, fromContentProtection(it))
+      }
+    }
+  }
+
+  fun fromContentProtection(contentProtection: ContentProtectionConfiguration): WritableMap {
+    return Arguments.createMap().apply {
+      putString(PROP_INTEGRATION, contentProtection.integration)
+      contentProtection.widevine?.let { config ->
+        putMap(PROP_WIDEVINE, fromKeySystemConfiguration(config))
+      }
+      contentProtection.playready?.let { config ->
+        putMap(PROP_PLAYREADY, fromKeySystemConfiguration(config))
+      }
+      contentProtection.fairplay?.let { config ->
+        putMap(PROP_FAIRPLAY, fromFairPlayConfiguration(config))
+      }
+    }
+  }
+
+  fun fromKeySystemConfiguration(config: KeySystemConfiguration): WritableMap {
+    return Arguments.createMap().apply {
+      config.licenseUrl?.let { url -> putString(PROP_LICENSE_URL, url) }
+    }
+  }
+
+  fun fromFairPlayConfiguration(config: FairPlayConfiguration): WritableMap {
+    return Arguments.createMap().apply {
+      config.licenseUrl?.let { url -> putString(PROP_LICENSE_URL, url) }
+      config.certificateUrl?.let { url -> putString(PROP_CERTIFICATE_URL, url) }
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/theolive/THEOliveEventAdapter.kt

@@ -0,0 +1,63 @@
+package com.theoplayer.theolive
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.theoplayer.android.api.event.player.theolive.DistributionLoadStartEvent
+import com.theoplayer.android.api.event.player.theolive.DistributionOfflineEvent
+import com.theoplayer.android.api.event.player.theolive.EndpointLoadedEvent
+import com.theoplayer.android.api.event.player.theolive.IntentToFallbackEvent
+import com.theoplayer.android.api.event.player.theolive.TheoLiveEventTypes
+import com.theoplayer.android.api.player.theolive.TheoLive
+
+private const val EVENT_PROP_TYPE = "type"
+
+private const val EVENT_PROP_DISTRIBUTION_ID = "distributionId"
+private const val EVENT_PROP_ENDPOINT = "endpoint"
+
+class THEOliveEventAdapter(private val theoLiveApi: TheoLive, private val emitter: Emitter) {
+
+  interface Emitter {
+    fun emit(payload: WritableMap?)
+  }
+
+  init {
+    theoLiveApi.addEventListener(TheoLiveEventTypes.DISTRIBUTIONLOADSTART, this::onDistributionLoadStart)
+    theoLiveApi.addEventListener(TheoLiveEventTypes.DISTRIBUTIONOFFLINE, this::onDistributionOffline)
+    theoLiveApi.addEventListener(TheoLiveEventTypes.ENDPOINTLOADED, this::onEndPointLoaded)
+    theoLiveApi.addEventListener(TheoLiveEventTypes.INTENTTOFALLBACK, this::onIntentOfFallback)
+  }
+
+  fun destroy() {
+    theoLiveApi.removeEventListener(TheoLiveEventTypes.DISTRIBUTIONLOADSTART, this::onDistributionLoadStart)
+    theoLiveApi.removeEventListener(TheoLiveEventTypes.DISTRIBUTIONOFFLINE, this::onDistributionOffline)
+    theoLiveApi.removeEventListener(TheoLiveEventTypes.ENDPOINTLOADED, this::onEndPointLoaded)
+    theoLiveApi.removeEventListener(TheoLiveEventTypes.INTENTTOFALLBACK, this::onIntentOfFallback)
+  }
+
+  private fun onDistributionLoadStart(event: DistributionLoadStartEvent) {
+    emitter.emit(Arguments.createMap().apply {
+      putString(EVENT_PROP_TYPE, "distributionloadstart")
+      putString(EVENT_PROP_DISTRIBUTION_ID, event.getDistributionId())
+    })
+  }
+
+  private fun onDistributionOffline(event: DistributionOfflineEvent) {
+    emitter.emit(Arguments.createMap().apply {
+      putString(EVENT_PROP_TYPE, "distributionoffline")
+      putString(EVENT_PROP_DISTRIBUTION_ID, event.getDistributionId())
+    })
+  }
+
+  private fun onEndPointLoaded(event: EndpointLoadedEvent) {
+    emitter.emit(Arguments.createMap().apply {
+      putString(EVENT_PROP_TYPE, "endpointloaded")
+      putMap(EVENT_PROP_ENDPOINT, EndpointAdapter.fromEndpoint(event.getEndpoint()))
+    })
+  }
+
+  private fun onIntentOfFallback(_event: IntentToFallbackEvent) {
+    emitter.emit(Arguments.createMap().apply {
+      putString(EVENT_PROP_TYPE, "intenttofallback")
+    })
+  }
+}

package/ios/THEOplayerRCTBridge.m

@@ -43,12 +43,12 @@ RCT_EXPORT_VIEW_PROPERTY(onNativeTextTrackListEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeTextTrackEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeMediaTrackListEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeMediaTrackEvent, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeDeviceOrientationChanged, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativePlayerReady, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativePresentationModeChange, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeResize, RCTDirectEventBlock);
-
 RCT_EXPORT_VIEW_PROPERTY(onNativeAdEvent, RCTDirectEventBlock);
-
+RCT_EXPORT_VIEW_PROPERTY(onNativeTHEOliveEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeCastEvent, RCTDirectEventBlock);
 
 @end

package/ios/THEOplayerRCTDeviceEventHandler.swift

@@ -0,0 +1,38 @@
+// THEOplayerRCTDeviceEventHandler.swift
+
+import Foundation
+import THEOplayerSDK
+
+public class THEOplayerRCTDeviceEventHandler {
+    // MARK: Events
+    var onNativeDeviceOrientationChanged: RCTDirectEventBlock?
+    
+    init() {
+#if os(iOS)
+        UIDevice.current.beginGeneratingDeviceOrientationNotifications()
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.handleOrientationChange),
+            name: UIDevice.orientationDidChangeNotification,
+            object: nil
+        )
+#endif
+    }
+    
+    func destroy() {
+#if os(iOS)
+        NotificationCenter.default.removeObserver(self, name: UIDevice.orientationDidChangeNotification, object: nil)
+        UIDevice.current.endGeneratingDeviceOrientationNotifications()
+#endif
+    }
+  
+#if os(iOS)
+    @objc private func handleOrientationChange() {
+        DispatchQueue.main.async {
+            if let forwardedNativeOrientationChanged = self.onNativeDeviceOrientationChanged {
+                forwardedNativeOrientationChanged([:])
+            }
+        }
+    }
+#endif
+}

package/ios/THEOplayerRCTSourceDescriptionBuilder.swift

@@ -59,6 +59,7 @@ let SD_PROP_OVERRIDE_LAYOUT: String = "overrideLayout"
 let SD_PROP_OVERRIDE_AD_SRC: String = "overrideAdSrc"
 let SD_PROP_USE_ID3: String = "useId3"
 let SD_PROP_RETRIEVE_POD_ID_URI: String = "retrievePodIdURI"
+let SD_PROP_INITIALIZATION_DELAY: String = "initializationDelay"
 let SD_PROP_HLS_DATE_RANGE: String = "hlsDateRange"
 let SD_PROP_CMCD: String = "cmcd"
 
@@ -185,12 +186,14 @@ class THEOplayerRCTSourceDescriptionBuilder {
      */
     private static func buildTypedSource(_ typedSourceData: [String:Any]) -> TypedSource? {
         let contentProtection = extractDrmConfiguration(from: typedSourceData)
+        let integration = typedSourceData[SD_PROP_INTEGRATION] as? String
+        let type = typedSourceData[SD_PROP_TYPE] as? String
         
-        if let integration = typedSourceData[SD_PROP_INTEGRATION] as? String, integration == "theolive" {
+        if integration == "theolive" || type == "theolive" {
             return THEOplayerRCTSourceDescriptionBuilder.buildTHEOliveDescription(typedSourceData)
         }
 
-        if let type = typedSourceData[SD_PROP_TYPE] as? String, type == "millicast" {
+        if type == "millicast" {
             return THEOplayerRCTSourceDescriptionBuilder.buildMillicastDescription(typedSourceData)
         }
 

package/ios/THEOplayerRCTView.swift

@@ -28,8 +28,10 @@ public class THEOplayerRCTView: UIView {
     public private(set) var broadcastEventHandler: THEOplayerRCTBroadcastEventHandler
     var textTrackEventHandler: THEOplayerRCTTextTrackEventHandler
     var mediaTrackEventHandler: THEOplayerRCTMediaTrackEventHandler
+    var deviceEventHandler: THEOplayerRCTDeviceEventHandler
     var metadataTrackEventHandler: THEOplayerRCTSideloadedMetadataTrackEventHandler
     var adEventHandler: THEOplayerRCTAdsEventHandler
+    var theoliveEventHandler: THEOplayerRCTTHEOliveEventHandler
     var castEventHandler: THEOplayerRCTCastEventHandler
     var presentationModeManager: THEOplayerRCTPresentationModeManager
     var backgroundAudioManager: THEOplayerRCTBackgroundAudioManager
@@ -93,8 +95,10 @@ public class THEOplayerRCTView: UIView {
         self.broadcastEventHandler = THEOplayerRCTBroadcastEventHandler()
         self.textTrackEventHandler = THEOplayerRCTTextTrackEventHandler()
         self.mediaTrackEventHandler = THEOplayerRCTMediaTrackEventHandler()
+        self.deviceEventHandler = THEOplayerRCTDeviceEventHandler()
         self.metadataTrackEventHandler = THEOplayerRCTSideloadedMetadataTrackEventHandler()
         self.adEventHandler = THEOplayerRCTAdsEventHandler()
+        self.theoliveEventHandler = THEOplayerRCTTHEOliveEventHandler()
         self.castEventHandler = THEOplayerRCTCastEventHandler()
         self.presentationModeManager = THEOplayerRCTPresentationModeManager()
         self.backgroundAudioManager = THEOplayerRCTBackgroundAudioManager()
@@ -114,7 +118,9 @@ public class THEOplayerRCTView: UIView {
         self.mainEventHandler.destroy()
         self.textTrackEventHandler.destroy()
         self.mediaTrackEventHandler.destroy()
+        self.deviceEventHandler.destroy()
         self.adEventHandler.destroy()
+        self.theoliveEventHandler.destroy()
         self.castEventHandler.destroy()
         self.nowPlayingManager.destroy()
         self.remoteCommandsManager.destroy()
@@ -149,6 +155,7 @@ public class THEOplayerRCTView: UIView {
             self.textTrackEventHandler.setPlayer(player)
             self.mediaTrackEventHandler.setPlayer(player)
             self.adEventHandler.setPlayer(player)
+            self.theoliveEventHandler.setPlayer(player)
             self.castEventHandler.setPlayer(player)
             self.nowPlayingManager.setPlayer(player)
             self.remoteCommandsManager.setPlayer(player)
@@ -389,6 +396,14 @@ public class THEOplayerRCTView: UIView {
         if DEBUG_VIEW { PrintUtils.printLog(logText: "[NATIVE] nativeMediaTrackEvent prop set.") }
     }
     
+    // MARK: - Observer based device event bridging
+    
+    @objc(setOnNativeDeviceOrientationChanged:)
+    func setOnNativeDeviceOrientationChanged(nativeDeviceOrientationChanged: @escaping RCTDirectEventBlock) {
+        self.deviceEventHandler.onNativeDeviceOrientationChanged = nativeDeviceOrientationChanged
+        if DEBUG_VIEW { PrintUtils.printLog(logText: "[NATIVE] nativeDeviceOrientationChanged prop set.") }
+    }
+    
     // MARK: - Listener based CAST event bridging
     
     @objc(setOnNativeCastEvent:)
@@ -404,4 +419,12 @@ public class THEOplayerRCTView: UIView {
         self.adEventHandler.onNativeAdEvent = nativeAdEvent
         if DEBUG_VIEW { PrintUtils.printLog(logText: "[NATIVE] nativeAdEvent prop set.") }
     }
+    
+    // MARK: - Listener based THEOLIVE event bridging
+    
+    @objc(setOnNativeTHEOliveEvent:)
+    func setOnNativeTHEOliveEvent(nativeTHEOliveEvent: @escaping RCTDirectEventBlock) {
+        self.theoliveEventHandler.onNativeTHEOliveEvent = nativeTHEOliveEvent
+        if DEBUG_VIEW { PrintUtils.printLog(logText: "[NATIVE] nativeTHEOliveEvent prop set.") }
+    }
 }

package/ios/theoAds/THEOplayerRCTSourceDescriptionBuilder+TheoAds.swift

@@ -48,6 +48,8 @@ extension THEOplayerRCTSourceDescriptionBuilder {
         let adTagParameters = adsData[SD_PROP_AD_TAG_PARAMETERS] as? [String:String]
         let useId3 = adsData[SD_PROP_USE_ID3] as? Bool
         let retrievePodIdURI = adsData[SD_PROP_RETRIEVE_POD_ID_URI] as? String
+        let initializationDelay = adsData[SD_PROP_INITIALIZATION_DELAY] as? Double
+        
         return THEOAdDescription(networkCode: networkCode,
                                  customAssetKey: customAssetKey,
                                  backdropDoubleBox: backdropDoubleBox,
@@ -57,7 +59,8 @@ extension THEOplayerRCTSourceDescriptionBuilder {
                                  adTagParameters: adTagParameters,
                                  useId3: useId3,
                                  sseEndpoint: sseEndpoint,
-                                 retrievePodIdURI: retrievePodIdURI)
+                                 retrievePodIdURI: retrievePodIdURI,
+                                 initializationDelay: initializationDelay)
 #else
         return nil
 #endif

package/ios/theolive/THEOplayerRCTTHEOliveAPI.swift

@@ -32,9 +32,9 @@ class THEOplayerRCTTHEOliveAPI: NSObject, RCTBridgeModule {
                let player = theView.player,
                let theolive = player.theoLive {
                 var foundLatency: Double = -1
-                /*if let currentLatency = theolive.currentLatency {
+                if let currentLatency = theolive.currentLatency {
                     foundLatency = currentLatency
-                }*/
+                }
                 resolve(foundLatency)
             } else {
                 if DEBUG_THEOLIVE_API { PrintUtils.printLog(logText: "[NATIVE] Could not get currentLatency (THEOlive module unavailable).") }
@@ -50,14 +50,14 @@ class THEOplayerRCTTHEOliveAPI: NSObject, RCTBridgeModule {
                let player = theView.player,
                let theolive = player.theoLive {
                 var foundLatencies: [String:Any] = [:]
-                /*if let latencies = theolive.latencies {
+                if let latencies = theolive.latencies {
                     foundLatencies = [
                         "engineLatency": latencies.engineLatency,
                         "distributionLatency": latencies.distributionLatency,
                         "playerLatency": latencies.playerLatency,
                         "theoliveLatency": latencies.theoliveLatency
                     ]
-                }*/
+                }
                 resolve(foundLatencies)
             } else {
                 if DEBUG_THEOLIVE_API { PrintUtils.printLog(logText: "[NATIVE] Could not get latencies (THEOlive module unavailable).") }

package/ios/theolive/THEOplayerRCTTHEOliveEventHandler.swift

@@ -0,0 +1,146 @@
+// THEOplayerRCTTHEOliveEventHandler.swift
+
+import Foundation
+import THEOplayerSDK
+
+#if canImport(THEOplayerTHEOliveIntegration)
+import THEOplayerTHEOliveIntegration
+#endif
+
+let EVENT_TYPE_DISTRIBUTION_LOAD_START: String = "distributionloadstart"
+let EVENT_TYPE_DISTRIBUTION_OFFLINE: String = "distributionoffline"
+let EVENT_TYPE_ENDPOINT_LOADED: String = "endpointloaded"
+let EVENT_TYPE_INTENT_TO_FALLBACK: String = "intenttofallback"
+
+let THEOLIVE_EVENT_PROP_TYPE: String = "type"
+let THEOLIVE_EVENT_PROP_DISTRIBUTION_ID: String = "distributionId"
+
+class THEOplayerRCTTHEOliveEventHandler {
+    // MARK: Members
+    private weak var player: THEOplayer?
+
+    // MARK: Events
+    var onNativeTHEOliveEvent: RCTDirectEventBlock?
+
+    // MARK: Ad Listeners
+    private var distributionLoadStartListener: EventListener?
+    private var distributionOfflineListener: EventListener?
+    private var endPointLoadedListener: EventListener?
+    private var intentToFallbackListener: 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 canImport(THEOplayerTHEOliveIntegration)
+        // DISTRIBUTION_LOAD_START
+        self.distributionLoadStartListener = player.theoLive?.addEventListener(type: THEOliveEventTypes.DISTRIBUTION_LOAD_START) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received DistributionLoadStart event from THEOlive") }
+            if let forwardedTHEOliveEvent = self?.onNativeTHEOliveEvent {
+                forwardedTHEOliveEvent([
+                    THEOLIVE_EVENT_PROP_TYPE: EVENT_TYPE_DISTRIBUTION_LOAD_START,
+                    THEOLIVE_EVENT_PROP_DISTRIBUTION_ID: event.distributionId
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] DistributionLoadStart listener attached to THEOplayer.theolive") }
+        
+        
+        // DISTRIBUTION_OFFLINE
+        self.distributionOfflineListener = player.theoLive?.addEventListener(type: THEOliveEventTypes.DISTRIBUTION_OFFLINE) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received DistributionOffline event from THEOlive") }
+            if let forwardedTHEOliveEvent = self?.onNativeTHEOliveEvent {
+                forwardedTHEOliveEvent([
+                    THEOLIVE_EVENT_PROP_TYPE: EVENT_TYPE_DISTRIBUTION_OFFLINE,
+                    THEOLIVE_EVENT_PROP_DISTRIBUTION_ID: event.distributionId
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] DistributionOffline listener attached to THEOplayer.theolive") }
+        
+        // ENDPOINT_LOADED
+        self.endPointLoadedListener = player.theoLive?.addEventListener(type: THEOliveEventTypes.ENDPOINT_LOADED) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received EndPointLoaded event from THEOlive") }
+            if let forwardedTHEOliveEvent = self?.onNativeTHEOliveEvent {
+                forwardedTHEOliveEvent([
+                    THEOLIVE_EVENT_PROP_TYPE: EVENT_TYPE_ENDPOINT_LOADED
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] EndPointLoaded listener attached to THEOplayer.theolive") }
+
+        // INTENT_TO_FALLBACK
+        self.intentToFallbackListener = player.theoLive?.addEventListener(type: THEOliveEventTypes.INTENT_TO_FALLBACK) { [weak self] event in
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received IntentToFallback event from THEOlive") }
+            if let forwardedTHEOliveEvent = self?.onNativeTHEOliveEvent {
+                forwardedTHEOliveEvent([
+                    THEOLIVE_EVENT_PROP_TYPE: EVENT_TYPE_INTENT_TO_FALLBACK
+                ])
+            }
+        }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] IntentToFallback listener attached to THEOplayer.theolive") }
+#endif
+    }
+
+    private func dettachListeners() {
+        guard let player = self.player else {
+            return
+        }
+
+#if canImport(THEOplayerTHEOliveIntegration)
+        // DISTRIBUTION_LOAD_START
+        if let distributionLoadStartListener = self.distributionLoadStartListener {
+            player.theoLive?.removeEventListener(
+                type: THEOliveEventTypes.DISTRIBUTION_LOAD_START,
+                listener: distributionLoadStartListener
+            )
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] DistributionLoadStart listener detached from THEOplayer.theolive") }
+        }
+        
+        // DISTRIBUTION_OFFLINE
+        if let distributionOfflineListener = self.distributionOfflineListener {
+            player.theoLive?.removeEventListener(
+                type: THEOliveEventTypes.DISTRIBUTION_OFFLINE,
+                listener: distributionOfflineListener
+            )
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] DistributionOffline listener detached from THEOplayer.theolive") }
+        }
+        
+        // ENDPOINT_LOADED
+        if let endPointLoadedListener = self.endPointLoadedListener {
+            player.theoLive?.removeEventListener(
+                type: THEOliveEventTypes.ENDPOINT_LOADED,
+                listener: endPointLoadedListener
+            )
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] EndPointLoaded listener detached from THEOplayer.theolive") }
+        }
+        
+        // INTENT_TO_FALLBACK
+        if let intentToFallbackListener = self.intentToFallbackListener {
+            player.theoLive?.removeEventListener(
+                type: THEOliveEventTypes.INTENT_TO_FALLBACK,
+                listener: intentToFallbackListener
+            )
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] IntentToFallback listener detached from THEOplayer.theolive") }
+        }
+        
+#endif
+
+    }
+}