react-native-theoplayer 10.0.0 → 10.2.0

package/CHANGELOG.md

@@ -5,6 +5,37 @@ 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).
 
+## [10.2.0] - 25-10-20
+
+### Fixed
+
+- Fixed an issue on iOS where the player crashed when it was destroyed while in fullscreen.
+- Fixed an issue on Android where creating a caching task with `MediaCache.createTask` would not return the created `task`.
+- Fixed an issue where setting `player.theoLive.authToken = undefined` would cause a crash on Android.
+
+### Changed
+
+- Added `THEOplayer.theoLive` and deprecated `THEOplayer.theolive`, to be consistent with the THEOplayer SDKs for other platforms.
+
+## [10.1.0] - 25-10-06
+
+### Added
+
+- Added an explicit clearing of the NowPlayingInfo on iOS, when the app receives a `willTerminateNotification`, to make sure all NowPlayingInfo is removed from the lock screen when an app is closed.
+- Added `videoWidth` and `videoHeight` properties to `THEOplayer` containing the active video's resolution in pixels.
+- Added `videoresize` player event enabling monitoring of video rendition resizes.
+- Added `dimensionchange` player event enabling monitoring of player resizes. This event is set to replace the now deprecated `resize` player event.
+- Added `fontPath` to `TextTrackStyle` to allow loading custom fonts from the Android assets folder.
+
+### Fixed
+
+- Fixed an issue on Android where play-out of Millicast sources in the example app would fail. The Android NDK version needs to be at least v28.
+- Fixed an issue on Web where on older devices the `display: contents` style property is sometimes not supported.
+- Fixed an issue on Android where the `MediaPlaybackService` could be restarted after the app was closed, in some cases causing a `ForegroundServiceDidNotStartInTimeException`. A conditional receiver makes sure the service is never restarted.
+- Fixed an issue on iOS where a setup with multiple players could cause a view index NSInternalInconsistencyException after moving players in and out of fullscreen.
+- Fixed an issue on Android where some event listeners were not properly disposed of after destroying the player.
+- Fixed an issue on Web where the `width` and `height` properties on `THEOplayer` would show the active video rendition's resolution width and height instead of the width and height of the video element.
+
 ## [10.0.0] - 25-09-15
 
 ### Added

package/android/build.gradle

@@ -43,12 +43,12 @@ def enabledMediaSession = safeExtGet("THEOplayer_extensionMediaSession", 'true')
 def enabledMillicast = safeExtGet("THEOplayer_extensionMillicast", 'false').toBoolean()
 
 android {
-    compileSdk safeExtGet('THEOplayer_compileSdkVersion', 35)
+    compileSdk safeExtGet('THEOplayer_compileSdkVersion', 36)
     namespace "com.theoplayer"
 
     defaultConfig {
         minSdkVersion safeExtGet('THEOplayer_minSdkVersion', 23)
-        targetSdkVersion safeExtGet('THEOplayer_targetSdkVersion', 35)
+        targetSdkVersion safeExtGet('THEOplayer_targetSdkVersion', 36)
         versionCode 1
         versionName "1.0"
 
@@ -124,8 +124,8 @@ repositories {
     mavenLocal()
 }
 
-// The minimum supported THEOplayer version is 9.9.0
-def theoVersion = safeExtGet('THEOplayer_sdk', '[9.9.0, 11.0.0)')
+// The minimum supported THEOplayer version is 10.0.1
+def theoVersion = safeExtGet('THEOplayer_sdk', '[10.0.1, 11.0.0)')
 def theoMediaSessionVersion = safeExtGet('THEOplayer_mediasession', '[8.0.0, 11.0.0)')
 def theoAdsWrapperVersion = "10.0.0"
 def coroutinesVersion = safeExtGet('coroutinesVersion', '1.10.2')
@@ -133,7 +133,6 @@ def appcompatVersion = safeExtGet('appcompatVersion', '1.7.1')
 def corektxVersion = safeExtGet('corektxVersion', '1.16.0')
 def gsonVersion = safeExtGet('gsonVersion', '2.13.1')
 def activityktxVersion = safeExtGet('activityktxVersion', '1.10.1')
-def millicastVersion = safeExtGet('millicastVersion', '2.5.0')
 
 dependencies {
     def addOptiViewIntegration = { enabled, notation, additional = null ->
@@ -169,5 +168,5 @@ dependencies {
     addOptiViewIntegration(enabledGoogleDAI || enabledTHEOads, 'integration-ads-dai')
     addOptiViewIntegration(enabledTHEOads, 'integration-ads-theoads')
     addOptiViewIntegration(enabledCast, 'integration-cast')
-    addOptiViewIntegration(enabledMillicast, 'integration-millicast', "com.millicast:millicast-sdk-android:$millicastVersion")
+    addOptiViewIntegration(enabledMillicast, 'integration-millicast')
 }

package/android/src/main/AndroidManifest.xml

@@ -41,7 +41,7 @@
       </intent-filter>
     </service>
 
-  <receiver android:name="androidx.media.session.MediaButtonReceiver"
+  <receiver android:name=".media.ConditionalMediaButtonReceiver"
     android:exported="false">
     <intent-filter>
       <action android:name="android.intent.action.MEDIA_BUTTON" />

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

@@ -82,7 +82,8 @@ private const val EVENT_THEOLIVE_EVENT = "onNativeTHEOliveEvent"
 private const val EVENT_THEOADS_EVENT = "onNativeTHEOadsEvent"
 private const val EVENT_PRESENTATIONMODECHANGE = "onNativePresentationModeChange"
 private const val EVENT_VOLUMECHANGE = "onNativeVolumeChange"
-private const val EVENT_RESIZE = "onNativeResize"
+private const val EVENT_DIMENSIONCHANGE = "onNativeDimensionChange"
+private const val EVENT_VIDEORESIZE = "onNativeVideoResize"
 
 private const val EVENT_PROP_TYPE = "type"
 private const val EVENT_PROP_STATE = "state"
@@ -126,7 +127,8 @@ class PlayerEventEmitter internal constructor(
     EVENT_THEOADS_EVENT,
     EVENT_PRESENTATIONMODECHANGE,
     EVENT_VOLUMECHANGE,
-    EVENT_RESIZE
+    EVENT_DIMENSIONCHANGE,
+    EVENT_VIDEORESIZE
   )
   annotation class VideoEvents
 
@@ -162,7 +164,8 @@ class PlayerEventEmitter internal constructor(
       EVENT_THEOADS_EVENT,
       EVENT_PRESENTATIONMODECHANGE,
       EVENT_VOLUMECHANGE,
-      EVENT_RESIZE
+      EVENT_DIMENSIONCHANGE,
+      EVENT_VIDEORESIZE
     )
   }
 
@@ -177,9 +180,9 @@ class PlayerEventEmitter internal constructor(
   private var theoAdsEventAdapter: THEOadsEventAdapter? = null
   private var lastTimeUpdate: Long = 0
   private var lastCurrentTime = 0.0
-  private var resizeListener = View.OnLayoutChangeListener { v, _, _, _, _, oldLeft, oldTop, oldRight, oldBottom ->
+  private var dimensionChangeListener = View.OnLayoutChangeListener { v, _, _, _, _, oldLeft, oldTop, oldRight, oldBottom ->
     if (v.width != oldRight - oldLeft || v.height != oldBottom - oldTop) {
-      onResize(v.width, v.height)
+      onDimensionChange(v.width, v.height)
     }
   }
 
@@ -233,6 +236,8 @@ class PlayerEventEmitter internal constructor(
       EventListener { event: PresentationModeChange -> onPresentationModeChange(event) }
     playerListeners[PlayerEventTypes.VOLUMECHANGE] =
       EventListener { event: VolumeChangeEvent -> onVolumeChange(event) }
+    playerListeners[PlayerEventTypes.RESIZE] =
+      EventListener { event: ResizeEvent -> onResize(event) }
     textTrackListeners[TextTrackListEventTypes.ADDTRACK] =
       EventListener { event: AddTrackEvent -> onTextTrackAdd(event) }
     textTrackListeners[TextTrackListEventTypes.REMOVETRACK] =
@@ -438,13 +443,20 @@ class PlayerEventEmitter internal constructor(
     )
   }
 
-  private fun onResize(width: Int, height: Int) {
+  private fun onDimensionChange(width: Int, height: Int) {
     receiveEvent(
-      EVENT_RESIZE,
+      EVENT_DIMENSIONCHANGE,
       PayloadBuilder().size(width, height).build()
     )
   }
 
+  private fun onResize(event: ResizeEvent) {
+    receiveEvent(
+      EVENT_VIDEORESIZE,
+      PayloadBuilder().videoSize(event.width, event.height).build()
+    )
+  }
+
   private val onTextTrackAddCue = EventListener<AddCueEvent> { event ->
     val payload = PayloadBuilder().textTrackCue(event.cue, event.track).build().apply {
       putInt(EVENT_PROP_TYPE, TextTrackCueEventType.ADD_CUE.type)
@@ -700,7 +712,7 @@ class PlayerEventEmitter internal constructor(
     }
 
     // Attach view size listener
-    playerView.addOnLayoutChangeListener(resizeListener)
+    playerView.addOnLayoutChangeListener(dimensionChangeListener)
   }
 
   fun removeListeners(player: Player?) {
@@ -737,7 +749,7 @@ class PlayerEventEmitter internal constructor(
     }
 
     // Remove view size listener
-    playerView.removeOnLayoutChangeListener(resizeListener)
+    playerView.removeOnLayoutChangeListener(dimensionChangeListener)
 
     castEventAdapter?.destroy()
     adEventAdapter?.destroy()

package/android/src/main/java/com/theoplayer/cache/CacheModule.kt

@@ -14,7 +14,6 @@ import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.google.gson.Gson
-import com.theoplayer.ads.AdsModule
 import com.theoplayer.util.ViewResolver
 import com.theoplayer.android.api.THEOplayerGlobal
 import com.theoplayer.android.api.cache.Cache
@@ -26,6 +25,7 @@ import com.theoplayer.android.api.event.cache.task.CachingTaskEventTypes
 import com.theoplayer.android.api.event.cache.task.CachingTaskProgressEvent
 import com.theoplayer.android.api.event.cache.task.CachingTaskStateChangeEvent
 import com.theoplayer.android.api.event.cache.tasklist.CachingTaskListEventTypes
+import com.theoplayer.cache.CacheAdapter.fromCachingTask
 import com.theoplayer.drm.ContentProtectionAdapter
 import com.theoplayer.source.SourceAdapter
 import org.json.JSONException
@@ -78,7 +78,7 @@ class CacheModule(private val context: ReactApplicationContext) :
           event.task?.let { task ->
             // Notify AddCachingTaskEvent event
             emit("onAddCachingTaskEvent", Arguments.createMap().apply {
-              putMap(PROP_TASK, CacheAdapter.fromCachingTask(task))
+              putMap(PROP_TASK, fromCachingTask(task))
             })
             // Add CachingTask listeners
             addCachingTaskListeners(task)
@@ -90,7 +90,7 @@ class CacheModule(private val context: ReactApplicationContext) :
           event.task?.let { task ->
             // Notify RemoveCachingTaskEvent event
             emit("onRemoveCachingTaskEvent", Arguments.createMap().apply {
-              putMap(PROP_TASK, CacheAdapter.fromCachingTask(event.task))
+              putMap(PROP_TASK, fromCachingTask(event.task))
             })
             // Remove CachingTask listeners
             removeCachingTaskListeners(task)
@@ -184,16 +184,15 @@ class CacheModule(private val context: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun createTask(source: ReadableMap, parameters: ReadableMap) {
-    val sourceDescription = sourceAdapter.parseSourceFromJS(source)
-    if (sourceDescription != null) {
+  fun createTask(source: ReadableMap, parameters: ReadableMap, promise: Promise) {
+    sourceAdapter.parseSourceFromJS(source)?.let { sourceDescription ->
       handler.post {
-        cache.createTask(
+        promise.resolve(fromCachingTask(cache.createTask(
           sourceDescription,
           CacheAdapter.parseCachingParameters(parameters)
-        )
+        )))
       }
-    }
+    } ?: promise.resolve(null)
   }
 
   @ReactMethod

package/android/src/main/java/com/theoplayer/cast/CastEventAdapter.kt

@@ -6,6 +6,7 @@ import com.theoplayer.android.api.cast.Cast
 import com.theoplayer.android.api.cast.chromecast.CastError
 import com.theoplayer.android.api.cast.chromecast.ErrorCode
 import com.theoplayer.android.api.cast.chromecast.PlayerCastState
+import com.theoplayer.android.api.event.EventListener
 import com.theoplayer.android.api.event.chromecast.CastErrorEvent
 import com.theoplayer.android.api.event.chromecast.CastStateChangeEvent
 import com.theoplayer.android.api.event.chromecast.ChromecastEventTypes
@@ -22,24 +23,27 @@ class CastEventAdapter(private val castApi: Cast, private val emitter: Emitter)
     fun emit(payload: WritableMap?)
   }
 
+  private val onCastError = EventListener<CastErrorEvent> { handleCastError(it) }
+  private val onStateChange = EventListener<CastStateChangeEvent> { handleStateChange(it) }
+
   init {
-    castApi.chromecast.addEventListener(ChromecastEventTypes.ERROR, this::onCastError)
-    castApi.chromecast.addEventListener(ChromecastEventTypes.STATECHANGE, this::onStateChange)
+    castApi.chromecast.addEventListener(ChromecastEventTypes.ERROR, onCastError)
+    castApi.chromecast.addEventListener(ChromecastEventTypes.STATECHANGE, onStateChange)
   }
 
   fun destroy() {
-    castApi.chromecast.removeEventListener(ChromecastEventTypes.ERROR, this::onCastError)
-    castApi.chromecast.removeEventListener(ChromecastEventTypes.STATECHANGE, this::onStateChange)
+    castApi.chromecast.removeEventListener(ChromecastEventTypes.ERROR, onCastError)
+    castApi.chromecast.removeEventListener(ChromecastEventTypes.STATECHANGE, onStateChange)
   }
 
-  private fun onCastError(event: CastErrorEvent) {
+  private fun handleCastError(event: CastErrorEvent) {
     val payload = Arguments.createMap()
     payload.putString(EVENT_PROP_TYPE, "chromecasterror")
     payload.putMap(EVENT_PROP_ERROR, serializeError(event.error))
     emitter.emit(payload)
   }
 
-  private fun serializeError(error: CastError): WritableMap  {
+  private fun serializeError(error: CastError): WritableMap {
     val errorPayload = Arguments.createMap()
     @Suppress("SENSELESS_NULL_IN_WHEN")
     errorPayload.putString(
@@ -62,7 +66,7 @@ class CastEventAdapter(private val castApi: Cast, private val emitter: Emitter)
     return errorPayload
   }
 
-  private fun onStateChange(event: CastStateChangeEvent) {
+  private fun handleStateChange(event: CastStateChangeEvent) {
     val payload = Arguments.createMap()
     payload.putString(EVENT_PROP_TYPE, "chromecaststatechange")
     if (event.state != null) {

package/android/src/main/java/com/theoplayer/media/ConditionalMediaButtonReceiver.kt

@@ -0,0 +1,38 @@
+package com.theoplayer.media
+
+import android.app.ActivityManager
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+/**
+ * A MediaButtonReceiver that only forwards MediaButton events if the MediaPlaybackService is
+ * running, otherwise ignore the event.
+ * This avoid the service is being restarted when the parent app was closed.
+ * It also avoids the ForegroundServiceDidNotStartInTimeException, which is sent when the
+ * service doesn't start in time (within 5 seconds) due to heavy load.
+ */
+class ConditionalMediaButtonReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+        if (Intent.ACTION_MEDIA_BUTTON == intent.action) {
+            // Only send the intent if service is already running.
+            if (isServiceRunning(context, MediaPlaybackService::class.java)) {
+                intent.setClass(context, MediaPlaybackService::class.java)
+                context.startService(intent)
+            }
+        }
+    }
+
+    private fun isServiceRunning(context: Context, serviceClass: Class<*>): Boolean {
+        val am = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        @Suppress("DEPRECATION") // Only alternative is usage stats, heavier
+        val runningServices = am.getRunningServices(Int.MAX_VALUE)
+        for (service in runningServices) {
+            if (serviceClass.name == service.service.className) {
+                return true
+            }
+        }
+        return false
+    }
+}

package/android/src/main/java/com/theoplayer/player/PlayerModule.kt

@@ -253,7 +253,7 @@ class PlayerModule(context: ReactApplicationContext) : ReactContextBaseJavaModul
   fun setTextTrackStyle(tag: Int, style: ReadableMap?) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
       view?.player?.let { player ->
-        TextTrackStyleAdapter.applyTextTrackStyle(player.textTrackStyle, style)
+        TextTrackStyleAdapter.applyTextTrackStyle(player.textTrackStyle, reactApplicationContext, style)
       }
     }
   }

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

@@ -427,7 +427,7 @@ class SourceAdapter {
   private fun parseCmcdTransmissionMode(cmcdConfiguration : JSONObject) : CMCDTransmissionMode {
     try {
       val transmissionMode = cmcdConfiguration.optInt(CMCD_TRANSMISSION_MODE)
-      if (transmissionMode === CmcdTransmissionMode.QUERY_ARGUMENT.ordinal) {
+      if (transmissionMode == CmcdTransmissionMode.QUERY_ARGUMENT.ordinal) {
         return CMCDTransmissionMode.QUERY_ARGUMENT
       }
       return CMCDTransmissionMode.HTTP_HEADER

package/android/src/main/java/com/theoplayer/theoads/THEOadsAdapter.kt

@@ -13,9 +13,10 @@ import com.theoplayer.android.api.ads.theoads.OverlaySize
 import com.theoplayer.android.api.ads.theoads.TheoAdsLayout
 
 private const val PROP_ID = "id"
-private const val PROP_TYPE = "TYPE"
+private const val PROP_TYPE = "type"
 private const val PROP_START_TIME = "startTime"
 private const val PROP_DURATION = "duration"
+private const val PROP_AD_TAG_PARAMETERS = "adTagParameters"
 private const val PROP_BACKDROP_URI = "backdropUri"
 private const val PROP_LAYOUT = "layout"
 private const val PROP_ADS = "ads"
@@ -62,6 +63,14 @@ object THEOadsAdapter {
         putMap(PROP_POSITION, fromOverlayPosition(interstitial.position))
         putMap(PROP_SIZE, fromOverlaySize(interstitial.size))
       }
+
+      putMap(PROP_AD_TAG_PARAMETERS, fromAdTagParameters(interstitial.adTagParameters))
+    }
+  }
+
+  fun fromAdTagParameters(adTagParameters: Map<String, String>): WritableMap {
+    return Arguments.createMap().apply {
+      adTagParameters.forEach { (key, value) -> putString(key, value) }
     }
   }
 

package/android/src/main/java/com/theoplayer/theoads/THEOadsEventAdapter.kt

@@ -8,6 +8,7 @@ import com.theoplayer.android.api.ads.theoads.event.InterstitialEvent
 import com.theoplayer.android.api.ads.theoads.event.TheoAdsErrorEvent
 import com.theoplayer.android.api.ads.theoads.event.TheoAdsEvent
 import com.theoplayer.android.api.ads.theoads.event.TheoAdsEventTypes
+import com.theoplayer.android.api.event.EventListener
 
 private const val EVENT_PROP_TYPE = "type"
 private const val EVENT_PROP_INTERSTITIAL = "interstitial"
@@ -27,15 +28,17 @@ class THEOadsEventAdapter(private val api: TheoAdsIntegration, private val emitt
     fun emit(payload: WritableMap?)
   }
 
+  private val onEvent = EventListener<TheoAdsEvent<*>> { handleEvent(it) }
+
   init {
-    FORWARDED_EVENTS.forEach { api.addEventListener(it, this::onEvent) }
+    FORWARDED_EVENTS.forEach { api.addEventListener(it, onEvent) }
   }
 
   fun destroy() {
-    FORWARDED_EVENTS.forEach { api.removeEventListener(it, this::onEvent) }
+    FORWARDED_EVENTS.forEach { api.removeEventListener(it, onEvent) }
   }
 
-  private fun onEvent(event: TheoAdsEvent<*>) {
+  private fun handleEvent(event: TheoAdsEvent<*>) {
     emitter.emit(Arguments.createMap().apply {
       putString(EVENT_PROP_TYPE, event.type.name)
       (event as? InterstitialEvent)?.let {

package/android/src/main/java/com/theoplayer/theoads/THEOadsModule.kt

@@ -60,4 +60,18 @@ class THEOadsModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
       }
     }
   }
+
+  @ReactMethod
+  fun setAdTagParameters(tag: Int, id: String, adTagParameters: ReadableMap) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      if (BuildConfig.EXTENSION_THEOADS) {
+        view?.player?.theoAds?.let { theoads ->
+          val interstitials = theoads.currentInterstitials + theoads.scheduledInterstitials
+          interstitials.find { it.id == id }?.let { interstitial ->
+            interstitial.adTagParameters = adTagParameters.toHashMap().mapValues { it.value.toString() }
+          }
+        }
+      }
+    }
+  }
 }

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

@@ -2,6 +2,7 @@ package com.theoplayer.theolive
 
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
+import com.theoplayer.android.api.event.EventListener
 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
@@ -21,18 +22,30 @@ class THEOliveEventAdapter(private val theoLiveApi: TheoLive, private val emitte
     fun emit(payload: WritableMap?)
   }
 
+  private val onDistributionLoadStart =
+    EventListener<DistributionLoadStartEvent> { onDistributionLoadStart(it) }
+  private val onDistributionOffline =
+    EventListener<DistributionOfflineEvent> { onDistributionOffline(it) }
+  private val onEndPointLoaded =
+    EventListener<EndpointLoadedEvent> { onEndPointLoaded(it) }
+  private val onIntentOfFallback =
+    EventListener<IntentToFallbackEvent> { onIntentOfFallback(it) }
+
   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)
+    theoLiveApi.addEventListener(TheoLiveEventTypes.DISTRIBUTIONLOADSTART, onDistributionLoadStart)
+    theoLiveApi.addEventListener(TheoLiveEventTypes.DISTRIBUTIONOFFLINE, onDistributionOffline)
+    theoLiveApi.addEventListener(TheoLiveEventTypes.ENDPOINTLOADED, onEndPointLoaded)
+    theoLiveApi.addEventListener(TheoLiveEventTypes.INTENTTOFALLBACK, 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)
+    theoLiveApi.removeEventListener(
+      TheoLiveEventTypes.DISTRIBUTIONLOADSTART,
+      onDistributionLoadStart
+    )
+    theoLiveApi.removeEventListener(TheoLiveEventTypes.DISTRIBUTIONOFFLINE, onDistributionOffline)
+    theoLiveApi.removeEventListener(TheoLiveEventTypes.ENDPOINTLOADED, onEndPointLoaded)
+    theoLiveApi.removeEventListener(TheoLiveEventTypes.INTENTTOFALLBACK, onIntentOfFallback)
   }
 
   private fun onDistributionLoadStart(event: DistributionLoadStartEvent) {

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

@@ -54,7 +54,7 @@ class THEOliveModule(context: ReactApplicationContext) : ReactContextBaseJavaMod
   }
 
   @ReactMethod
-  fun setAuthToken(tag: Int, token: String) {
+  fun setAuthToken(tag: Int, token: String?) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
       view?.player?.theoLive?.authToken = token
     }

package/android/src/main/java/com/theoplayer/track/TextTrackStyleAdapter.kt

@@ -1,6 +1,8 @@
 package com.theoplayer.track
 
 import android.graphics.Color
+import android.graphics.Typeface
+import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.theoplayer.android.api.player.track.texttrack.TextTrackStyle
 
@@ -10,6 +12,7 @@ private const val PROP_EDGE_COLOR = "edgeColor"
 private const val PROP_FONT_COLOR = "fontColor"
 private const val PROP_FONT_FAMILY = "fontFamily"
 private const val PROP_FONT_SIZE = "fontSize"
+private const val PROP_FONT_PATH = "fontPath"
 private const val PROP_WINDOW_COLOR = "windowColor"
 private const val PROP_MARGIN_LEFT = "marginLeft"
 private const val PROP_MARGIN_RIGHT = "marginRight"
@@ -22,7 +25,7 @@ private const val PROP_COLOR_A = "a"
 
 object TextTrackStyleAdapter {
 
-  fun applyTextTrackStyle(style: TextTrackStyle, props: ReadableMap?) {
+  fun applyTextTrackStyle(style: TextTrackStyle, context: ReactApplicationContext, props: ReadableMap?) {
     if (props == null) {
       return
     }
@@ -65,6 +68,10 @@ object TextTrackStyleAdapter {
     if (props.hasKey(PROP_MARGIN_RIGHT)) {
       style.marginRight = props.getInt(PROP_MARGIN_RIGHT)
     }
+    if (props.hasKey(PROP_FONT_PATH)) {
+      val font = Typeface.createFromAsset(context.assets, props.getString(PROP_FONT_PATH))
+      style.font = font
+    }
   }
 
   private fun edgeStyleFromProps(style: String?): TextTrackStyle.EdgeType {

package/android/src/main/java/com/theoplayer/util/PayloadBuilder.kt

@@ -57,6 +57,9 @@ private const val EVENT_PROP_MUTED = "muted"
 private const val EVENT_PROP_WIDTH = "width"
 private const val EVENT_PROP_HEIGHT = "height"
 
+private const val EVENT_PROP_VIDEO_WIDTH = "videoWidth"
+private const val EVENT_PROP_VIDEO_HEIGHT = "videoHeight"
+
 class PayloadBuilder {
   private val payload: WritableMap = Arguments.createMap()
 
@@ -138,6 +141,11 @@ class PayloadBuilder {
     payload.putInt(EVENT_PROP_WIDTH, width)
     payload.putInt(EVENT_PROP_HEIGHT, height)
   }
+
+  fun videoSize(videoWidth: Int, videoHeight: Int) = apply {
+    payload.putInt(EVENT_PROP_VIDEO_WIDTH, videoWidth)
+    payload.putInt(EVENT_PROP_VIDEO_HEIGHT, videoHeight)
+  }
   fun seekable(ranges: TimeRanges?) = apply {
     payload.putArray(EVENT_PROP_SEEKABLE, fromTimeRanges(ranges))
   }

package/ios/THEOplayerRCTBridge.m

@@ -46,7 +46,8 @@ 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(onNativeDimensionChange, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeVideoResize, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeAdEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeTHEOliveEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeTHEOadsEvent, RCTDirectEventBlock);
@@ -119,6 +120,8 @@ RCT_EXTERN_METHOD(setTextTrackStyle:(nonnull NSNumber *)node
 RCT_EXTERN_METHOD(setKeepScreenOn:(nonnull NSNumber *)node
                   keepScreenOn:(BOOL)keepScreenOn)
 
+RCT_EXTERN_METHOD(willUnmount:(nonnull NSNumber *)node)
+
 RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getUsableScreenDimensions)
 
 @end
@@ -302,5 +305,9 @@ RCT_EXTERN_METHOD(scheduledInterstitials:(nonnull NSNumber *)node
 RCT_EXTERN_METHOD(replaceAdTagParameters:(nonnull NSNumber *)node
                   adTagParameters:(nullable NSDictionary *)adTagParameters)
 
+RCT_EXTERN_METHOD(setAdTagParameters:(nonnull NSNumber *)node
+                  id:(nonnull NSString *)id
+                  adTagParameters:(nullable NSDictionary *)adTagParameters)
+
 @end
 

package/ios/THEOplayerRCTMainEventHandler.swift

@@ -29,7 +29,8 @@ public class THEOplayerRCTMainEventHandler {
     var onNativeRateChange: RCTDirectEventBlock?
     var onNativeWaiting: RCTDirectEventBlock?
     var onNativeCanPlay: RCTDirectEventBlock?
-    var onNativeResize: RCTDirectEventBlock?
+    var onNativeDimensionChange: RCTDirectEventBlock?
+    var onNativeVideoResize: RCTDirectEventBlock?
     
     // MARK: player Listeners
     private var playListener: EventListener?
@@ -51,11 +52,10 @@ public class THEOplayerRCTMainEventHandler {
     private var rateChangeListener: EventListener?
     private var waitingListener: EventListener?
     private var canPlayListener: EventListener?
-    private var resizeListener: EventListener?
-    private var presentationModeChangeListener: EventListener?
+    private var videoResizeListener: EventListener?
     
     // MARK: player observer
-    private var videoRectObserver: NSKeyValueObservation?
+    private var dimensionChangeObserver: NSKeyValueObservation?
     
     // MARK: - destruction
     func destroy() {
@@ -310,27 +310,27 @@ public class THEOplayerRCTMainEventHandler {
         }
         if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] CanPlay listener attached to THEOplayer") }
         
-        // RESIZE: TODO on iOS SDK
-        /*self.resizeListener = player.addEventListener(type: PlayerEventTypes.RESIZE) { [weak self, weak player] event in
+        // RESIZE
+        self.videoResizeListener = player.addEventListener(type: PlayerEventTypes.RESIZE) { [weak self, weak player] event in
             if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received RESIZE event from THEOplayer") }
             if let wplayer = player,
-               let forwardedResizeEvent = self?.onNativeResize {
-                forwardedResizeEvent(
+               let forwardedVideoResizeEvent = self?.onNativeVideoResize {
+                forwardedVideoResizeEvent(
                     [
-                        "width": wplayer.frame.width,
-                        "height": wplayer.frame.height,
+                        "videoWidth": wplayer.videoWidth,
+                        "videoHeight": wplayer.videoHeight,
                     ]
                 )
             }
         }
-        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Resize listener attached to THEOplayer") }*/
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Resize listener attached to THEOplayer") }
         
-        // RESIZE: implemented using videoRect Observation
-        self.videoRectObserver = player.observe(\.videoRect, options: [.new]) { [weak self, weak player] view, change in
+        // DIMENSION CHANGE: implemented using videoRect Observation
+        self.dimensionChangeObserver = player.observe(\.videoRect, options: [.new]) { [weak self, weak player] view, change in
             if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Observed videoRect change on THEOplayer") }
             if let wplayer = player,
-               let forwardedResizeEvent = self?.onNativeResize {
-                forwardedResizeEvent(
+               let forwardedDimensionChangeEvent = self?.onNativeDimensionChange {
+                forwardedDimensionChangeEvent(
                     [
                         "width": wplayer.frame.width,
                         "height": wplayer.frame.height,
@@ -453,12 +453,15 @@ public class THEOplayerRCTMainEventHandler {
             if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] CanPlay listener dettached from THEOplayer") }
         }
         
+        // DIMENSION CHANGE
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Invalidate dimensionChangeObserver from THEOplayer") }
+        self.dimensionChangeObserver?.invalidate()
+        self.dimensionChangeObserver = nil
+      
         // RESIZE
-        /*if let resizeListener = self.resizeListener {
-            player.removeEventListener(type: PlayerEventTypes.RESIZE, listener: resizeListener)
-            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Resize listener dettached from THEOplayer") }
-        }*/
-        self.videoRectObserver?.invalidate()
-        self.videoRectObserver = nil
+        if let videoResizeListener = self.videoResizeListener {
+          player.removeEventListener(type: PlayerEventTypes.RESIZE, listener: videoResizeListener)
+          if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Resize listener dettached from THEOplayer") }
+        }
     }
 }