react-native-theoplayer 3.2.1 → 3.3.1

package/CHANGELOG.md

@@ -5,6 +5,19 @@ 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).
 
+## [3.3.1] - 23-12-11
+
+### Fixed
+
+- Fixed an issue on Android where a `ContentResumeRequested` ad event was never broadcasted.
+- Fixed an issue on iOS where the ad duration was provided in milliseconds instead of seconds.
+
+## [3.3.0] - 23-12-11
+
+### Changed
+
+- Extended event dispatching mechanism with broadcast functionality.
+
 ## [3.2.1] - 23-12-07
 
 ### Fixed

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

@@ -8,6 +8,7 @@ import com.theoplayer.ads.AdsModule
 import com.theoplayer.cache.CacheModule
 import com.theoplayer.drm.ContentProtectionModule
 import com.theoplayer.cast.CastModule
+import com.theoplayer.broadcast.EventBroadcastModule
 import com.theoplayer.player.PlayerModule
 
 class ReactTHEOplayerPackage : ReactPackage {
@@ -17,7 +18,8 @@ class ReactTHEOplayerPackage : ReactPackage {
       AdsModule(reactContext),
       ContentProtectionModule(reactContext),
       CastModule(reactContext),
-      CacheModule(reactContext)
+      CacheModule(reactContext),
+      EventBroadcastModule(reactContext)
     )
   }
 

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

@@ -11,6 +11,7 @@ import com.theoplayer.android.api.ads.wrapper.AdsApiWrapper
 import com.theoplayer.android.api.cast.Cast
 import com.theoplayer.android.api.error.THEOplayerException
 import com.theoplayer.android.api.player.Player
+import com.theoplayer.broadcast.EventBroadcastAdapter
 import com.theoplayer.presentation.PresentationManager
 import com.theoplayer.source.SourceAdapter
 
@@ -22,7 +23,7 @@ class ReactTHEOplayerView(private val reactContext: ThemedReactContext) :
 
   private val eventEmitter: PlayerEventEmitter =
     PlayerEventEmitter(reactContext.reactApplicationContext, this)
-
+  val broadcast = EventBroadcastAdapter(this)
   var presentationManager: PresentationManager? = null
   var playerContext: ReactTHEOplayerContext? = null
   private var isInitialized: Boolean = false

package/android/src/main/java/com/theoplayer/ads/AdAdapter.kt

@@ -1,12 +1,17 @@
 package com.theoplayer.ads
 
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableArray
+import com.google.ads.interactivemedia.v3.api.AdPodInfo
+import com.google.ads.interactivemedia.v3.api.UiElement
 import com.theoplayer.android.api.ads.Ad
 import com.theoplayer.android.api.ads.AdBreak
 import com.theoplayer.android.api.ads.CompanionAd
 import com.theoplayer.android.api.ads.GoogleImaAd
+import com.theoplayer.android.api.ads.UniversalAdId
+import com.theoplayer.android.api.event.ads.AdIntegrationKind
 import java.lang.Exception
 
 private const val PROP_AD_SYSTEM = "adSystem"
@@ -42,11 +47,13 @@ private const val PROP_COMPANION_RESOURCEURI = "resourceURI"
 private const val PROP_UNIVERSAL_AD_ID_REGISTRY = "adIdRegistry"
 private const val PROP_UNIVERSAL_AD_ID_VALUE = "adIdValue"
 
-object AdAdapter {
-  fun fromAd(ad: Ad): WritableMap {
-    return fromAd(ad, true)
-  }
+private const val INVALID_DOUBLE = -1.0
+private const val INVALID_INT = -1
 
+object AdAdapter {
+  /**
+   * Convert a list of native Ads to a ReactNative Ads.
+   */
   fun fromAds(ads: List<Ad>): WritableArray {
     val payload = Arguments.createArray()
     for (ad in ads) {
@@ -55,6 +62,16 @@ object AdAdapter {
     return payload
   }
 
+  /**
+   * Convert a native Ad to a ReactNative Ad.
+   */
+  fun fromAd(ad: Ad): WritableMap {
+    return fromAd(ad, true)
+  }
+
+  /**
+   * Convert a native Ad to a ReactNative Ad, optionally include its AdBreak.
+   */
   private fun fromAd(ad: Ad, includeAdBreak: Boolean): WritableMap {
     val adPayload = Arguments.createMap()
     adPayload.putString(
@@ -113,6 +130,9 @@ object AdAdapter {
     return adPayload
   }
 
+  /**
+   * Convert a native AdBreak to a ReactNative AdBreak.
+   */
   fun fromAdBreak(adbreak: AdBreak?): WritableMap {
     val adbreakPayload = Arguments.createMap()
     if (adbreak == null) {
@@ -158,4 +178,275 @@ object AdAdapter {
     }
     return companionsPayload
   }
+
+  /**
+   * Convert a ReactNative Ad to a native Ad.
+   */
+  fun parseAd(ad: ReadableMap?): GoogleImaAd? {
+    if (ad == null) {
+      return null
+    }
+    return object: GoogleImaAd {
+      override fun getId(): String {
+        return ad.getString(PROP_AD_ID) ?: ""
+      }
+
+      override fun getCompanions(): List<CompanionAd> {
+        return emptyList()
+      }
+
+      override fun getType(): String? {
+        return ad.getString(PROP_AD_TYPE)
+      }
+
+      override fun getAdBreak(): AdBreak? {
+        return parseAdBreak(ad.getMap(PROP_AD_BREAK))
+      }
+
+      override fun getSkipOffset(): Int {
+        return if (ad.hasKey(PROP_AD_SKIPOFFSET)) ad.getInt(PROP_AD_SKIPOFFSET) else 0
+      }
+
+      override fun getIntegration(): AdIntegrationKind {
+        return AdIntegrationKind.from(ad.getString(PROP_AD_INTEGRATION))
+      }
+
+      override fun getImaAd(): com.google.ads.interactivemedia.v3.api.Ad {
+        return parseImaAd(ad)
+      }
+
+      override fun getAdSystem(): String {
+        return ad.getString(PROP_AD_SYSTEM) ?: ""
+      }
+
+      override fun getCreativeId(): String? {
+        return ad.getString(PROP_AD_CREATIVE_ID)
+      }
+
+      override fun getWrapperAdIds(): List<String> {
+        return emptyList()
+      }
+
+      override fun getWrapperAdSystems(): List<String> {
+        return emptyList()
+      }
+
+      override fun getWrapperCreativeIds(): List<String> {
+        return emptyList()
+      }
+
+      override fun getVastMediaBitrate(): Int {
+        return if (ad.hasKey(PROP_AD_BITRATE)) ad.getInt(PROP_AD_BITRATE) else 0
+      }
+
+      override fun getUniversalAdIds(): List<UniversalAdId> {
+        return emptyList()
+      }
+
+      override fun getTraffickingParameters(): String {
+        return ad.getString(PROP_AD_TRAFFICKING_PARAMETERS) ?: ""
+      }
+    }
+  }
+
+  fun parseAdBreak(adBreak: ReadableMap?): AdBreak? {
+    if (adBreak == null) {
+      return null
+    }
+    return object: AdBreak {
+      override fun getAds(): List<Ad> {
+        return emptyList()
+      }
+
+      override fun getMaxDuration(): Int {
+        return if (adBreak.hasKey(PROP_ADBREAK_MAXDURATION))
+          (1e-3 * adBreak.getInt(PROP_ADBREAK_MAXDURATION)).toInt()
+        else
+          INVALID_INT
+      }
+
+      override fun getMaxRemainingDuration(): Double {
+        return if (adBreak.hasKey(PROP_ADBREAK_MAXREMAININGDURATION))
+          1e-3 * adBreak.getDouble(PROP_ADBREAK_MAXREMAININGDURATION)
+        else
+          INVALID_DOUBLE
+      }
+
+      override fun getTimeOffset(): Int {
+        return if (adBreak.hasKey(PROP_ADBREAK_TIMEOFFSET))
+          (1e-3 * adBreak.getInt(PROP_ADBREAK_TIMEOFFSET)).toInt()
+        else
+          0
+      }
+
+      override fun getIntegration(): AdIntegrationKind {
+        return AdIntegrationKind.from(adBreak.getString(PROP_ADBREAK_INTEGRATION))
+      }
+    }
+  }
+
+  fun parseImaAd(ad: ReadableMap?): com.google.ads.interactivemedia.v3.api.Ad {
+    return object: com.google.ads.interactivemedia.v3.api.Ad {
+      override fun getDuration(): Double {
+        return ad?.run {
+          if (hasKey(PROP_AD_DURATION)) 1e-3 * getDouble(PROP_AD_DURATION) else INVALID_DOUBLE
+        } ?: INVALID_DOUBLE
+      }
+
+      override fun getSkipTimeOffset(): Double {
+        return ad?.run {
+          if (hasKey(PROP_AD_SKIPOFFSET)) 1e-3 * getDouble(PROP_AD_SKIPOFFSET) else INVALID_DOUBLE
+        } ?: INVALID_DOUBLE
+      }
+
+      override fun getHeight(): Int {
+        return ad?.run {
+          if (hasKey(PROP_AD_HEIGHT)) getInt(PROP_AD_HEIGHT) else INVALID_INT
+        } ?: INVALID_INT
+      }
+
+      override fun getVastMediaBitrate(): Int {
+        return ad?.run {
+          if (hasKey(PROP_AD_BITRATE)) getInt(PROP_AD_BITRATE) else INVALID_INT
+        } ?: INVALID_INT
+      }
+
+      override fun getVastMediaHeight(): Int {
+        return ad?.run {
+          if (hasKey(PROP_AD_HEIGHT)) getInt(PROP_AD_HEIGHT) else INVALID_INT
+        } ?: INVALID_INT
+      }
+
+      override fun getVastMediaWidth(): Int {
+        return ad?.run {
+          if (hasKey(PROP_AD_WIDTH)) getInt(PROP_AD_WIDTH) else INVALID_INT
+        } ?: INVALID_INT
+      }
+
+      override fun getWidth(): Int {
+        return ad?.run {
+          if (hasKey(PROP_AD_WIDTH)) getInt(PROP_AD_WIDTH) else INVALID_INT
+        } ?: INVALID_INT
+      }
+
+      override fun getAdPodInfo(): AdPodInfo {
+        return object: AdPodInfo {
+          override fun getMaxDuration(): Double {
+            return INVALID_DOUBLE
+          }
+
+          override fun getTimeOffset(): Double {
+            return INVALID_DOUBLE
+          }
+
+          override fun getAdPosition(): Int {
+            return INVALID_INT
+          }
+
+          override fun getPodIndex(): Int {
+            return INVALID_INT
+          }
+
+          override fun getTotalAds(): Int {
+            return INVALID_INT
+          }
+
+          override fun isBumper(): Boolean {
+            return false
+          }
+        }
+      }
+
+      override fun getAdId(): String {
+        return ad?.getString(PROP_AD_ID) ?: ""
+      }
+
+      override fun getAdSystem(): String {
+        return ad?.getString(PROP_AD_SYSTEM) ?: ""
+      }
+
+      override fun getAdvertiserName(): String {
+        return ""
+      }
+
+      override fun getContentType(): String {
+        return ad?.getString(PROP_AD_CONTENT_TYPE) ?: ""
+      }
+
+      override fun getCreativeAdId(): String {
+        return ""
+      }
+
+      override fun getCreativeId(): String {
+        return ad?.getString(PROP_AD_CREATIVE_ID) ?: ""
+      }
+
+      override fun getDealId(): String {
+        return ""
+      }
+
+      override fun getDescription(): String {
+        return ""
+      }
+
+      override fun getSurveyUrl(): String {
+        return ""
+      }
+
+      override fun getTitle(): String {
+        return ad?.getString(PROP_AD_TITLE) ?: ""
+      }
+
+      override fun getTraffickingParameters(): String {
+        return ad?.getString(PROP_AD_TRAFFICKING_PARAMETERS) ?: ""
+      }
+
+      @Deprecated("Deprecated in Java")
+      override fun getUniversalAdIdRegistry(): String {
+        return ""
+      }
+
+      @Deprecated("Deprecated in Java")
+      override fun getUniversalAdIdValue(): String {
+        return ad?.getString(PROP_UNIVERSAL_AD_ID_VALUE) ?: ""
+      }
+
+      override fun getCompanionAds(): List<com.google.ads.interactivemedia.v3.api.CompanionAd> {
+        return emptyList()
+      }
+
+      override fun getUiElements(): Set<UiElement> {
+        return emptySet()
+      }
+
+      override fun isLinear(): Boolean {
+        // Only linear ads are supported currently
+        return true
+      }
+
+      override fun isSkippable(): Boolean {
+        return false
+      }
+
+      override fun isUiDisabled(): Boolean {
+        return false
+      }
+
+      override fun getUniversalAdIds(): Array<com.google.ads.interactivemedia.v3.api.UniversalAdId> {
+        return emptyArray()
+      }
+
+      override fun getAdWrapperCreativeIds(): Array<String> {
+        return emptyArray()
+      }
+
+      override fun getAdWrapperIds(): Array<String> {
+        return emptyArray()
+      }
+
+      override fun getAdWrapperSystems(): Array<String> {
+        return emptyArray()
+      }
+    }
+  }
 }

package/android/src/main/java/com/theoplayer/ads/AdEventAdapter.kt

@@ -1,10 +1,13 @@
 package com.theoplayer.ads
 
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
 import com.theoplayer.android.api.ads.wrapper.AdsApiWrapper
 import com.facebook.react.bridge.WritableMap
 import com.theoplayer.android.api.ads.Ad
 import com.theoplayer.android.api.ads.AdBreak
+import com.theoplayer.android.api.ads.GoogleImaAd
+import com.theoplayer.android.api.ads.ima.GoogleImaAdEvent
 import com.theoplayer.android.api.ads.ima.GoogleImaAdEventType
 import com.theoplayer.android.api.ads.wrapper.AdEventListener
 import com.theoplayer.android.api.event.EventType
@@ -13,6 +16,8 @@ import java.util.*
 
 private const val EVENT_PROP_AD = "ad"
 private const val EVENT_PROP_TYPE = "type"
+private const val EVENT_PROP_SUBTYPE = "subType"
+
 private val ALL_AD_EVENTS = arrayOf(
   GoogleImaAdEventType.LOADED,
   GoogleImaAdEventType.AD_BREAK_STARTED,
@@ -64,21 +69,64 @@ class AdEventAdapter(private val adsApi: AdsApiWrapper, eventEmitter: AdEventEmi
     }
   }
 
-  private fun mapAdType(eventType: EventType<*>): String {
-    return when (eventType as GoogleImaAdEventType) {
-      GoogleImaAdEventType.LOADED -> "adloaded"
-      GoogleImaAdEventType.STARTED -> "adbegin"
-      GoogleImaAdEventType.FIRST_QUARTILE -> "adfirstquartile"
-      GoogleImaAdEventType.MIDPOINT -> "admidpoint"
-      GoogleImaAdEventType.THIRD_QUARTILE -> "adthirdquartile"
-      GoogleImaAdEventType.COMPLETED -> "adend"
-      GoogleImaAdEventType.SKIPPED -> "adskip"
-      GoogleImaAdEventType.AD_ERROR -> "aderror"
-      GoogleImaAdEventType.AD_BUFFERING -> "adbuffering"
-      GoogleImaAdEventType.AD_BREAK_STARTED -> "adbreakbegin"
-      GoogleImaAdEventType.AD_BREAK_ENDED -> "adbreakend"
-      GoogleImaAdEventType.AD_BREAK_FETCH_ERROR -> "aderror"
-      else -> eventType.getName().lowercase(Locale.getDefault())
+  companion object {
+
+    /**
+     * Create a native GoogleImaAdEvent from a ReactNative AdEvent.
+     */
+    fun parseEvent(event: ReadableMap?): GoogleImaAdEvent? {
+      val eventType = mapAdType(event?.getString(EVENT_PROP_SUBTYPE))
+      return if (event != null && eventType != null) {
+        object : GoogleImaAdEvent {
+          override val ad: GoogleImaAd?
+            get() = AdAdapter.parseAd(event.getMap(EVENT_PROP_AD))
+          override val adData: Map<String, String>
+            get() = mapOf()
+          override fun getDate(): Date {
+            return Date()
+          }
+          override fun getType(): EventType<GoogleImaAdEvent> {
+            return eventType
+          }
+        }
+      } else {
+        null
+      }
+    }
+
+    private fun mapAdType(eventType: String?): EventType<GoogleImaAdEvent>? {
+      return when (eventType) {
+        "adloaded" -> GoogleImaAdEventType.LOADED
+        "adbegin" -> GoogleImaAdEventType.STARTED
+        "adfirstquartile" -> GoogleImaAdEventType.FIRST_QUARTILE
+        "admidpoint" -> GoogleImaAdEventType.MIDPOINT
+        "adthirdquartile" -> GoogleImaAdEventType.THIRD_QUARTILE
+        "adend" -> GoogleImaAdEventType.COMPLETED
+        "adskip" -> GoogleImaAdEventType.SKIPPED
+        "aderror" -> GoogleImaAdEventType.AD_ERROR
+        "adbuffering" -> GoogleImaAdEventType.AD_BUFFERING
+        "adbreakbegin" -> GoogleImaAdEventType.AD_BREAK_STARTED
+        "adbreakend" -> GoogleImaAdEventType.CONTENT_RESUME_REQUESTED
+        else -> null /*unknown*/
+      }
+    }
+
+    private fun mapAdType(eventType: EventType<*>): String {
+      return when (eventType as GoogleImaAdEventType) {
+        GoogleImaAdEventType.LOADED -> "adloaded"
+        GoogleImaAdEventType.STARTED -> "adbegin"
+        GoogleImaAdEventType.FIRST_QUARTILE -> "adfirstquartile"
+        GoogleImaAdEventType.MIDPOINT -> "admidpoint"
+        GoogleImaAdEventType.THIRD_QUARTILE -> "adthirdquartile"
+        GoogleImaAdEventType.COMPLETED -> "adend"
+        GoogleImaAdEventType.SKIPPED -> "adskip"
+        GoogleImaAdEventType.AD_ERROR -> "aderror"
+        GoogleImaAdEventType.AD_BUFFERING -> "adbuffering"
+        GoogleImaAdEventType.AD_BREAK_STARTED -> "adbreakbegin"
+        GoogleImaAdEventType.AD_BREAK_ENDED -> "adbreakend"
+        GoogleImaAdEventType.AD_BREAK_FETCH_ERROR -> "aderror"
+        else -> eventType.getName().lowercase(Locale.getDefault())
+      }
     }
   }
 

package/android/src/main/java/com/theoplayer/broadcast/DefaultEventDispatcher.kt

@@ -0,0 +1,27 @@
+package com.theoplayer.broadcast
+
+import com.theoplayer.android.api.event.EventDispatcher
+import com.theoplayer.android.api.event.EventListener
+import com.theoplayer.android.api.event.EventType
+import com.theoplayer.android.api.event.Event
+
+open class DefaultEventDispatcher: EventDispatcher<Event<*>> {
+    private val _listeners = mutableMapOf<EventType<*>, MutableList<EventListener<*>>>()
+
+    override fun <T : Event<*>> addEventListener(eventType: EventType<T>, listener: EventListener<in T>) {
+        if (!_listeners.contains(eventType)) {
+            _listeners[eventType] = mutableListOf()
+        }
+        _listeners[eventType]?.add(listener)
+    }
+
+    override fun <T : Event<*>> removeEventListener(eventType: EventType<T>, listener: EventListener<in T>) {
+       _listeners[eventType]?.remove(listener)
+    }
+
+    fun dispatchEvent(event: Event<*>) {
+        _listeners[event.type]?.forEach { listener ->
+            (listener as EventListener<Event<*>>).handleEvent(event)
+        }
+    }
+}

package/android/src/main/java/com/theoplayer/broadcast/EventAdapter.kt

@@ -0,0 +1,23 @@
+package com.theoplayer.broadcast
+
+import android.util.Log
+import com.facebook.react.bridge.ReadableMap
+import com.theoplayer.ads.AdEventAdapter
+import com.theoplayer.android.api.event.Event
+
+private const val EVENT_PROP_TYPE = "type"
+private const val PROP_AD_EVENT = "adevent"
+
+private const val TAG = "EventAdapter"
+
+object EventAdapter {
+  fun parseEvent(event: ReadableMap?): Event<*>? {
+    return when (val eventType = event?.getString(EVENT_PROP_TYPE)) {
+      PROP_AD_EVENT -> AdEventAdapter.parseEvent(event)
+      else -> {
+          Log.w(TAG, "Forwarding events of type $eventType not supported yet.")
+        null
+      } /*not supported yet*/
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/broadcast/EventBroadcastAdapter.kt

@@ -0,0 +1,15 @@
+package com.theoplayer.broadcast
+
+import com.facebook.react.bridge.ReadableMap
+import com.theoplayer.ReactTHEOplayerView
+
+class EventBroadcastAdapter(private val view: ReactTHEOplayerView): DefaultEventDispatcher() {
+  /**
+   * Convert a react-native event to a native event and broadcast it.
+   */
+  fun broadcastEvent(event: ReadableMap) {
+    EventAdapter.parseEvent(event)?.also {
+      view.broadcast.dispatchEvent(it)
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/broadcast/EventBroadcastModule.kt

@@ -0,0 +1,36 @@
+@file:Suppress("unused")
+package com.theoplayer.broadcast
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.theoplayer.ReactTHEOplayerView
+import com.theoplayer.util.ViewResolver
+
+private const val TAG = "EventBroadcastModule"
+
+@ReactModule(name = TAG)
+class EventBroadcastModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+
+  private val viewResolver: ViewResolver
+
+  init {
+    viewResolver = ViewResolver(context)
+  }
+
+  override fun getName(): String {
+    return TAG
+  }
+
+  /**
+   * Receive a react-native broadcast event and route it to the player's broadcast adapter.
+   */
+  @ReactMethod
+  fun broadcastEvent(tag: Int, event: ReadableMap) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.broadcast?.broadcastEvent(event)
+    }
+  }
+}

package/ios/THEOplayerRCTBridge.m

@@ -239,3 +239,13 @@ RCT_EXTERN_METHOD(renewLicense:(nonnull NSString *)id
                   drmConfig:(NSDictionary)drmConfig)
 
 @end
+
+// ----------------------------------------------------------------------------
+// Broadcast Module
+// ----------------------------------------------------------------------------
+@interface RCT_EXTERN_REMAP_MODULE(EventBroadcastModule, THEOplayerRCTEventBroadcastAPI, NSObject)
+
+RCT_EXTERN_METHOD(broadcastEvent:(nonnull NSNumber *)node
+                  event:(NSDictionary)event)
+
+@end

package/ios/THEOplayerRCTTypeUtils.swift

@@ -98,6 +98,23 @@ class THEOplayerRCTTypeUtils {
             return TextTrackStyleEdgeStyle.none
         }
 	}
+    
+    class func adIntegrationKind(_ integration: String) -> AdIntegrationKind {
+        switch integration {
+        case "theo":
+            return AdIntegrationKind.theo
+        case "freewheel":
+            return AdIntegrationKind.freewheel
+        case "google-ima":
+            return AdIntegrationKind.google_ima
+        case "google-dai":
+            return AdIntegrationKind.google_dai
+        case "":
+            return AdIntegrationKind.defaultKind
+        default:
+            return AdIntegrationKind.defaultKind
+        }
+    }
 
 #if os(iOS)
     class func cacheStatusToString(_ status: CacheStatus) -> String {

package/ios/THEOplayerRCTView.swift

@@ -8,6 +8,7 @@ public class THEOplayerRCTView: UIView {
     // MARK: Members
     public private(set) var player: THEOplayer?
     public private(set) var mainEventHandler: THEOplayerRCTMainEventHandler
+    public private(set) var broadcastEventHandler: THEOplayerRCTBroadcastEventHandler
     var textTrackEventHandler: THEOplayerRCTTextTrackEventHandler
     var mediaTrackEventHandler: THEOplayerRCTMediaTrackEventHandler
     var adEventHandler: THEOplayerRCTAdsEventHandler
@@ -44,6 +45,7 @@ public class THEOplayerRCTView: UIView {
     init() {
         // create event handlers to maintain event props
         self.mainEventHandler = THEOplayerRCTMainEventHandler()
+        self.broadcastEventHandler = THEOplayerRCTBroadcastEventHandler()
         self.textTrackEventHandler = THEOplayerRCTTextTrackEventHandler()
         self.mediaTrackEventHandler = THEOplayerRCTMediaTrackEventHandler()
         self.adEventHandler = THEOplayerRCTAdsEventHandler()