react-native-theoplayer 1.8.2 → 2.0.0

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

@@ -1,447 +1,143 @@
 package com.theoplayer
 
 import android.annotation.SuppressLint
-import android.os.Build
-import android.os.Handler
-import android.os.Looper
+import android.content.*
 import android.util.Log
+import android.view.ViewGroup
 import android.widget.FrameLayout
 import com.facebook.react.bridge.*
-import com.theoplayer.util.TypeUtils.encodeInfNan
-import com.theoplayer.android.api.ads.ima.GoogleImaIntegrationFactory.createGoogleImaIntegration
-import com.theoplayer.android.api.ads.dai.GoogleDaiIntegrationFactory.createGoogleDaiIntegration
-import com.theoplayer.android.api.cast.CastIntegrationFactory.createCastIntegration
 import com.facebook.react.uimanager.ThemedReactContext
-import com.theoplayer.android.api.THEOplayerView
-import com.theoplayer.android.api.ads.dai.GoogleDaiIntegration
-import com.theoplayer.android.api.ads.ima.GoogleImaIntegration
-import com.theoplayer.android.api.cast.CastIntegration
 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.android.api.source.SourceDescription
-import com.theoplayer.android.api.player.track.texttrack.TextTrack
-import com.theoplayer.android.api.player.track.texttrack.cue.TextTrackCue
-import com.theoplayer.android.api.THEOplayerConfig
-import com.google.ads.interactivemedia.v3.api.AdsRenderingSettings
-import com.google.ads.interactivemedia.v3.api.ImaSdkFactory
-import com.theoplayer.abr.ABRConfigurationAdapter
+import com.theoplayer.presentation.PresentationManager
 import com.theoplayer.source.SourceAdapter
-import com.theoplayer.android.api.error.THEOplayerException
-import com.theoplayer.android.api.player.track.texttrack.TextTrackMode
-import com.theoplayer.android.api.player.track.mediatrack.quality.AudioQuality
-import com.theoplayer.android.api.player.track.mediatrack.quality.VideoQuality
-import com.theoplayer.android.api.cast.Cast
-import com.theoplayer.android.api.player.track.mediatrack.MediaTrack
-import com.theoplayer.android.api.timerange.TimeRanges
-import com.theoplayer.track.QualityListFilter
-import com.theoplayer.track.TrackListAdapter
-import java.lang.Exception
 
 private const val TAG = "ReactTHEOplayerView"
-private const val TIME_UNSET = Long.MIN_VALUE + 1
 
 @SuppressLint("ViewConstructor")
 class ReactTHEOplayerView(private val reactContext: ThemedReactContext) :
   FrameLayout(reactContext), LifecycleEventListener {
 
-  private val eventEmitter: PlayerEventEmitter = PlayerEventEmitter(reactContext.reactApplicationContext, this)
-  private var playerView: THEOplayerView? = null
-  private var abrConfig: ReadableMap? = null
-  private var paused = false
-  private var muted = false
-  private var fullscreen = false
-  private var playbackRate = 1.0
-  private var volume = 1.0
-  private var seekTime = TIME_UNSET.toDouble()
-  private var sourceDescription: SourceDescription? = null
-  private val mainHandler = Handler(Looper.getMainLooper())
-  private val trackListAdapter = TrackListAdapter()
+  private val eventEmitter: PlayerEventEmitter =
+    PlayerEventEmitter(reactContext.reactApplicationContext, this)
+
+  var presentationManager: PresentationManager? = null
+  var playerContext: ReactTHEOplayerContext? = null
+  private var isInitialized: Boolean = false
 
-  var daiIntegration: GoogleDaiIntegration? = null
-  var imaIntegration: GoogleImaIntegration? = null
-  var castIntegration: CastIntegration? = null
   val adsApi: AdsApiWrapper
-  var player: Player? = null
+
+  val castApi: Cast?
+    get() = playerContext?.playerView?.cast
+
+  val player: Player?
+    get() = playerContext?.player
 
   init {
     reactContext.addLifecycleEventListener(this)
     adsApi = AdsApiWrapper()
   }
 
-  val castApi: Cast?
-    get() = if (playerView != null) playerView!!.cast else null
-
-  val textTrackInfo: WritableArray
-    get() = if (player != null) {
-      trackListAdapter.fromTextTrackList(player!!.textTracks)
-    } else Arguments.createArray()
-
   fun initialize(configProps: ReadableMap?) {
-    createViews(PlayerConfigAdapter.fromProps(configProps))
-  }
-
-  fun getTextTrackInfo(track: TextTrack): WritableMap {
-    return if (player != null) {
-      trackListAdapter.fromTextTrack(track)
-    } else Arguments.createMap()
-  }
-
-  fun getTextTrackCueInfo(cue: TextTrackCue): WritableMap {
-    return if (player != null) {
-      trackListAdapter.fromTextTrackCue(cue)
-    } else Arguments.createMap()
-  }
-
-  val audioTrackInfo: WritableArray
-    get() = if (player != null) {
-      trackListAdapter.fromAudioTrackList(player!!.audioTracks)
-    } else Arguments.createArray()
-
-  val videoTrackInfo: WritableArray
-    get() = if (player != null) {
-      trackListAdapter.fromVideoTrackList(player!!.videoTracks)
-    } else Arguments.createArray()
-
-  val duration: Double
-    get() = encodeInfNan(if (player != null) 1e03 * player!!.duration else Double.NaN)
-
-  fun getSeekableRange() : TimeRanges? {
-    return player?.seekable
-  }
-
-  override fun setId(id: Int) {
-    super.setId(id)
-    eventEmitter.setViewId(id)
-  }
-
-  private fun createViews(playerConfig: THEOplayerConfig) {
     if (BuildConfig.LOG_VIEW_EVENTS) {
-      Log.d(TAG, "Create views")
+      Log.d(TAG, "Initialize view")
     }
-
-    playerView = object : THEOplayerView(reactContext.currentActivity!!, playerConfig) {
-      private fun measureAndLayout() {
-        measure(
-          MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY),
-          MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY)
-        )
-        layout(left, top, right, bottom)
-      }
-
-      override fun requestLayout() {
-        super.requestLayout()
-
-        // schedule a forced layout
-        mainHandler.post { measureAndLayout() }
+    if (isInitialized) {
+      Log.w(TAG, "Already initialized view")
+      return
+    }
+    isInitialized = true
+    playerContext = ReactTHEOplayerContext.create(
+      reactContext,
+      PlayerConfigAdapter.theoConfigFromProps(configProps)
+    )
+    playerContext?.let {
+      if (BuildConfig.EXTENSION_ADS) {
+        adsApi.initialize(it.player, it.imaIntegration, it.daiIntegration)
       }
-    }.also {
       val layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
-      it.layoutParams = layoutParams
-      addIntegrations(it, playerConfig)
-      addView(it, 0, layoutParams)
-    }
-  }
+      it.playerView.layoutParams = layoutParams
+      (it.playerView.parent as? ViewGroup)?.removeView(it.playerView)
+      addView(it.playerView, 0, layoutParams)
 
-  private fun addIntegrations(playerView: THEOplayerView, playerConfig: THEOplayerConfig) {
-    try {
-      if (BuildConfig.EXTENSION_GOOGLE_IMA) {
-        imaIntegration = createGoogleImaIntegration(playerView).apply {
-          setAdsRenderingSettings(createRenderSettings(playerConfig))
-          playerView.player.addIntegration(this)
-        }
-      }
-    } catch (ignore: Exception) {
-    }
-    try {
-      if (BuildConfig.EXTENSION_GOOGLE_DAI) {
-        daiIntegration = createGoogleDaiIntegration(playerView).apply {
-          setAdsRenderingSettings(createRenderSettings(playerConfig))
-          playerView.player.addIntegration(this)
-        }
-      }
-    } catch (ignore: Exception) {
-    }
-    try {
-      if (BuildConfig.EXTENSION_CAST) {
-        castIntegration = createCastIntegration(playerView).apply {
-          playerView.player.addIntegration(this)
-        }
-      }
-      // Add other future integrations here.
-    } catch (ignore: Exception) {
-    }
-  }
+      presentationManager = PresentationManager(
+        it,
+        reactContext,
+        eventEmitter
+      )
 
-  private fun createRenderSettings(playerConfig: THEOplayerConfig): AdsRenderingSettings {
-    val renderingSettings = ImaSdkFactory.getInstance().createAdsRenderingSettings()
-    if (playerConfig.ads != null && !playerConfig.ads!!.isShowCountdown) {
-      renderingSettings.setUiElements(emptySet())
-      renderingSettings.disableUi = true
+      eventEmitter.preparePlayer(it.player)
     }
-    return renderingSettings
   }
 
-  override fun onAttachedToWindow() {
-    if (BuildConfig.LOG_VIEW_EVENTS) {
-      Log.d(TAG, "onAttachedToWindow")
-    }
-    super.onAttachedToWindow()
-    initializePlayer()
+  override fun setId(id: Int) {
+    super.setId(id)
+    eventEmitter.setViewId(id)
   }
 
-  override fun onDetachedFromWindow() {
+  /**
+   * Called when host activity receives pause event (e.g. {@link Activity#onPause}. Always called
+   * for the most current activity.
+   */
+  override fun onHostPause() {
     if (BuildConfig.LOG_VIEW_EVENTS) {
-      Log.d(TAG, "onDetachedFromWindow")
+      Log.d(TAG, "onHostPause")
+    }
+    if (presentationManager?.shouldPauseOnHostPause != false) {
+      playerContext?.onHostPause()
     }
-    super.onDetachedFromWindow()
-  }
-
-  private fun initializePlayer() {
-    // This ensures all props have been settled, to avoid async racing conditions.
-    mainHandler.postDelayed({
-      if (player == null) {
-        player = playerView!!.player
-        ABRConfigurationAdapter.applyABRConfigurationFromProps(player, abrConfig)
-        if (BuildConfig.EXTENSION_ADS) {
-          adsApi.initialize(player!!, imaIntegration, daiIntegration)
-        }
-        eventEmitter.attachListeners(player!!)
-        player?.isMuted = muted
-        player?.volume = volume
-        player?.playbackRate = playbackRate
-        setSource(sourceDescription)
-        if (!paused) {
-          player?.play()
-        }
-        if (seekTime != TIME_UNSET.toDouble()) {
-          seekTo(seekTime)
-        }
-      }
-    }, 1)
   }
 
+  /**
+   * Called either when the host activity receives a resume event (e.g. {@link Activity#onResume} or
+   * if the native module that implements this is initialized while the host activity is already
+   * resumed. Always called for the most current activity.
+   */
   override fun onHostResume() {
     if (BuildConfig.LOG_VIEW_EVENTS) {
       Log.d(TAG, "onHostResume")
     }
-    playerView?.onResume()
-  }
-
-  override fun onHostPause() {
-    if (BuildConfig.LOG_VIEW_EVENTS) {
-      Log.d(TAG, "onHostPause")
-    }
-    playerView?.onPause()
+    playerContext?.onHostResume()
   }
 
+  /**
+   * Called when host activity receives destroy event (e.g. {@link Activity#onDestroy}. Only called
+   * for the last React activity to be destroyed.
+   */
   override fun onHostDestroy() {
     if (BuildConfig.LOG_VIEW_EVENTS) {
       Log.d(TAG, "onHostDestroy")
     }
-    cleanUpResources()
+    releasePlayer()
   }
 
-  fun cleanUpResources() {
+  fun releasePlayer() {
     if (BuildConfig.LOG_VIEW_EVENTS) {
-      Log.d(TAG, "cleanUpResources")
+      Log.d(TAG, "releasePlayer")
     }
-    setFullscreen(false)
-    releasePlayer()
-  }
+    reactContext.removeLifecycleEventListener(this)
+    adsApi.destroy()
 
-  private fun releasePlayer() {
-    player?.let {
-      eventEmitter.removeListeners(it)
-      adsApi.destroy()
-      it.stop()
-      player = null
+    if (isInitialized) {
+      eventEmitter.removeListeners(player)
+      presentationManager?.destroy()
+      playerContext?.destroy()
+      isInitialized = false
     }
-    playerView?.onDestroy()
-    reactContext.removeLifecycleEventListener(this)
   }
 
   fun setSource(source: ReadableMap?) {
     try {
-      setSource(SourceAdapter().parseSourceFromJS(source!!))
+      val sourceDescription = SourceAdapter().parseSourceFromJS(source)
+      adsApi.setSource(sourceDescription)
+      if (sourceDescription != null) {
+        player?.source = sourceDescription
+      }
     } catch (exception: THEOplayerException) {
-      Log.e(TAG, exception.message!!)
+      Log.e(TAG, exception.message ?: "")
       eventEmitter.emitError(exception)
     }
   }
-
-  fun setABRConfig(abrConfigProps: ReadableMap?) {
-    abrConfig = abrConfigProps
-    ABRConfigurationAdapter.applyABRConfigurationFromProps(player, abrConfig)
-  }
-
-  fun setSource(sourceDescription: SourceDescription?) {
-    this.sourceDescription = sourceDescription
-    adsApi.setSource(sourceDescription)
-    if (player != null && sourceDescription != null) {
-      player!!.source = sourceDescription
-    }
-  }
-
-  fun setPaused(paused: Boolean) {
-    this.paused = paused
-    if (player != null) {
-      val playerIsPaused = player!!.isPaused
-      if (!paused && playerIsPaused) {
-        applyPaused(false)
-      } else if (paused && (!playerIsPaused || adsApi.isPlaying)) {
-        applyPaused(true)
-      } else {
-        // The player's paused state is out-of-sync, this shouldn't happen.
-        Log.w(TAG, "paused stated out-of-sync")
-        applyPaused(paused)
-      }
-    }
-  }
-
-  private fun applyPaused(paused: Boolean) {
-    if (paused) {
-      player?.pause()
-    } else {
-      player?.play()
-    }
-  }
-
-  fun setMuted(muted: Boolean) {
-    this.muted = muted
-    player?.isMuted = muted
-  }
-
-  fun setVolume(volume: Double) {
-    this.volume = volume
-    player?.volume = volume
-  }
-
-  fun setPlaybackRate(playbackRate: Double) {
-    this.playbackRate = playbackRate
-    player?.playbackRate = playbackRate
-  }
-
-  fun seekTo(seekTime: Double) {
-    this.seekTime = seekTime
-    player?.let {
-      it.currentTime = 1e-03 * seekTime
-
-      // reset once used
-      this.seekTime = TIME_UNSET.toDouble()
-    }
-  }
-
-  val selectedTextTrack: TextTrack?
-    get() {
-      if (player != null) {
-        val tracks = player!!.textTracks
-        for (i in 0 until tracks.length()) {
-          val track = tracks.getItem(i)
-          if (track.mode == TextTrackMode.SHOWING) {
-            return track
-          }
-        }
-      }
-      return null
-    }
-
-  fun setSelectedTextTrack(uid: Int) {
-    if (player != null) {
-      for (track in player!!.textTracks) {
-        if (track.uid == uid) {
-          track.mode = TextTrackMode.SHOWING
-        } else if (track.mode == TextTrackMode.SHOWING) {
-          track.mode = TextTrackMode.DISABLED
-        }
-      }
-    }
-  }
-
-  val selectedAudioTrack: MediaTrack<AudioQuality>?
-    get() {
-      if (player != null) {
-        val tracks = player!!.audioTracks
-        for (i in 0 until tracks.length()) {
-          val track = tracks.getItem(i)
-          if (track.isEnabled) {
-            return track
-          }
-        }
-      }
-      return null
-    }
-
-  fun setSelectedAudioTrack(uid: Int) {
-    if (player != null) {
-      for (track in player!!.audioTracks) {
-        track.isEnabled = track.uid == uid
-      }
-    }
-  }
-
-  val selectedVideoTrack: MediaTrack<VideoQuality?>?
-    get() {
-      if (player != null) {
-        val tracks = player!!.videoTracks
-        for (i in 0 until tracks.length()) {
-          val track = tracks.getItem(i)
-          if (track.isEnabled) {
-            return track
-          }
-        }
-      }
-      return null
-    }
-
-  fun setSelectedVideoTrack(uid: Int) {
-    if (player != null) {
-      for (track in player!!.videoTracks) {
-        track.isEnabled = track.uid == uid
-      }
-    }
-  }
-
-  fun setTargetVideoQualities(uids: ReadableArray) {
-    @Suppress("UNCHECKED_CAST") val currentVideoTrack = selectedVideoTrack as MediaTrack<VideoQuality>?
-    if (currentVideoTrack != null) {
-      if (uids.size() == 0) {
-        // Reset target qualities when passing empty list.
-        currentVideoTrack.setTargetQuality(null)
-      } else {
-        currentVideoTrack.qualities?.let {
-          currentVideoTrack.targetQualities = QualityListFilter(it).filterQualityList(uids)
-        }
-      }
-    }
-  }
-
-  @SuppressLint("ObsoleteSdkInt")
-  fun setFullscreen(fullscreen: Boolean) {
-    if (fullscreen == this.fullscreen) {
-      return
-    }
-    this.fullscreen = fullscreen
-    val activity = reactContext.currentActivity ?: return
-    val window = activity.window
-    val decorView = window.decorView
-    val uiOptions: Int
-    if (fullscreen) {
-      uiOptions = if (Build.VERSION.SDK_INT >= 19) { // 4.4+
-        (SYSTEM_UI_FLAG_HIDE_NAVIGATION
-          or SYSTEM_UI_FLAG_IMMERSIVE_STICKY
-          or SYSTEM_UI_FLAG_FULLSCREEN)
-      } else {
-        (SYSTEM_UI_FLAG_HIDE_NAVIGATION
-          or SYSTEM_UI_FLAG_FULLSCREEN)
-      }
-      eventEmitter.onFullscreenWillPresent()
-      decorView.systemUiVisibility = uiOptions
-      eventEmitter.onFullscreenDidPresent()
-    } else {
-      uiOptions = SYSTEM_UI_FLAG_VISIBLE
-      eventEmitter.onFullscreenWillDismiss()
-      decorView.systemUiVisibility = uiOptions
-      eventEmitter.onFullscreenDidDismiss()
-    }
-  }
 }

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

@@ -6,24 +6,11 @@ import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.common.MapBuilder
 
 private const val REACT_CLASS = "THEOplayerRCTView"
 
 private const val PROP_CONFIG = "config"
-private const val PROP_ABR_CONFIG = "abrConfig"
-private const val PROP_SRC = "src"
-private const val PROP_SEEK = "seek"
-private const val PROP_PAUSED = "paused"
-private const val PROP_MUTED = "muted"
-private const val PROP_VOLUME = "volume"
-private const val PROP_PLAYBACKRATE = "playbackRate"
-private const val PROP_FULLSCREEN = "fullscreen"
-private const val PROP_SELECTED_TEXTTRACK = "selectedTextTrack"
-private const val PROP_SELECTED_AUDIOTRACK = "selectedAudioTrack"
-private const val PROP_SELECTED_VIDEOTRACK = "selectedVideoTrack"
-private const val PROP_TARGET_VIDEOQUALITY = "targetVideoQuality"
 
 class ReactTHEOplayerViewManager : ViewGroupManager<ReactTHEOplayerView>() {
   override fun getName(): String {
@@ -34,8 +21,12 @@ class ReactTHEOplayerViewManager : ViewGroupManager<ReactTHEOplayerView>() {
     return ReactTHEOplayerView(reactContext)
   }
 
+  /**
+   * Called when view is detached from view hierarchy and allows for some additional cleanup by the
+   * {@link ViewManager} subclass.
+   */
   override fun onDropViewInstance(view: ReactTHEOplayerView) {
-    view.cleanUpResources()
+    view.releasePlayer()
   }
 
   @ReactProp(name = PROP_CONFIG)
@@ -43,70 +34,6 @@ class ReactTHEOplayerViewManager : ViewGroupManager<ReactTHEOplayerView>() {
     videoView.initialize(config)
   }
 
-  @ReactProp(name = PROP_ABR_CONFIG)
-  fun setABRConfig(videoView: ReactTHEOplayerView, config: ReadableMap?) {
-    videoView.setABRConfig(config)
-  }
-
-  @ReactProp(name = PROP_SRC)
-  fun setSource(videoView: ReactTHEOplayerView, src: ReadableMap?) {
-    videoView.setSource(src)
-  }
-
-  @ReactProp(name = PROP_SEEK)
-  fun setSeek(videoView: ReactTHEOplayerView, seek: Double) {
-    videoView.seekTo(seek)
-  }
-
-  @ReactProp(name = PROP_PAUSED, defaultBoolean = false)
-  fun setPaused(videoView: ReactTHEOplayerView, paused: Boolean) {
-    videoView.setPaused(paused)
-  }
-
-  @ReactProp(name = PROP_MUTED, defaultBoolean = false)
-  fun setMuted(videoView: ReactTHEOplayerView, muted: Boolean) {
-    videoView.setMuted(muted)
-  }
-
-  @ReactProp(name = PROP_VOLUME, defaultDouble = 1.0)
-  fun setVolume(videoView: ReactTHEOplayerView, volume: Double) {
-    videoView.setVolume(volume)
-  }
-
-  @ReactProp(name = PROP_PLAYBACKRATE, defaultDouble = 1.0)
-  fun setPlaybackRate(videoView: ReactTHEOplayerView, playbackRate: Double) {
-    videoView.setPlaybackRate(playbackRate)
-  }
-
-  @ReactProp(name = PROP_FULLSCREEN, defaultBoolean = false)
-  fun setFullscreen(videoView: ReactTHEOplayerView, fullscreen: Boolean) {
-    videoView.setFullscreen(fullscreen)
-  }
-
-  @ReactProp(name = PROP_SELECTED_TEXTTRACK, defaultInt = -1)
-  fun setSelectedTextTrack(videoView: ReactTHEOplayerView, uid: Int) {
-    videoView.setSelectedTextTrack(uid)
-  }
-
-  @ReactProp(name = PROP_SELECTED_AUDIOTRACK, defaultInt = -1)
-  fun setSelectedAudioTrack(videoView: ReactTHEOplayerView, uid: Int) {
-    if (uid != -1) {
-      videoView.setSelectedAudioTrack(uid)
-    }
-  }
-
-  @ReactProp(name = PROP_SELECTED_VIDEOTRACK, defaultInt = -1)
-  fun setSelectedVideoTrack(videoView: ReactTHEOplayerView, uid: Int) {
-    if (uid != -1) {
-      videoView.setSelectedVideoTrack(uid)
-    }
-  }
-
-  @ReactProp(name = PROP_TARGET_VIDEOQUALITY)
-  fun setTargetVideoQuality(videoView: ReactTHEOplayerView, uid: ReadableArray) {
-    videoView.setTargetVideoQualities(uid)
-  }
-
   override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> {
     val builder = MapBuilder.builder<String, Any>()
     for (event in PlayerEventEmitter.Events) {

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

@@ -95,7 +95,7 @@ class AdsModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(c
   @ReactMethod
   fun daiSnapback(tag: Int, promise: Promise) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
-      val daiIntegration = view?.daiIntegration
+      val daiIntegration = view?.playerContext?.daiIntegration
       if (daiIntegration == null) {
         promise.resolve(false)
       } else {
@@ -107,7 +107,7 @@ class AdsModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(c
   @ReactMethod
   fun daiSetSnapback(tag: Int, enabled: Boolean?) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
-      val daiIntegration = view?.daiIntegration
+      val daiIntegration = view?.playerContext?.daiIntegration
       if (daiIntegration != null) {
         daiIntegration.enableSnapback = enabled!!
       }
@@ -117,7 +117,7 @@ class AdsModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(c
   @ReactMethod
   fun daiContentTimeForStreamTime(tag: Int, time: Int, promise: Promise) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
-      val daiIntegration = view?.daiIntegration
+      val daiIntegration = view?.playerContext?.daiIntegration
       if (daiIntegration == null) {
         promise.resolve(time)
       } else {
@@ -129,7 +129,7 @@ class AdsModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(c
   @ReactMethod
   fun daiStreamTimeForContentTime(tag: Int, time: Int, promise: Promise) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
-      val daiIntegration = view?.daiIntegration
+      val daiIntegration = view?.playerContext?.daiIntegration
       if (daiIntegration == null) {
         promise.resolve(time)
       } else {

package/android/src/main/java/com/theoplayer/audio/AudioBecomingNoisyManager.kt

@@ -0,0 +1,32 @@
+package com.theoplayer.audio
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.media.AudioManager
+
+class AudioBecomingNoisyManager(private val context: Context, onAudioBecomingNoisy: () -> Unit) {
+
+  private class BecomingNoisyReceiver(private val onAudioBecomingNoisy: () -> Unit) : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+      if (intent.action == AudioManager.ACTION_AUDIO_BECOMING_NOISY) {
+        onAudioBecomingNoisy()
+      }
+    }
+  }
+
+  private val noisyAudioStreamReceiver: BecomingNoisyReceiver = BecomingNoisyReceiver(onAudioBecomingNoisy)
+  private val intentFilter = IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY)
+  private var registered: Boolean = false
+
+  fun setEnabled(enabled: Boolean) {
+    if (enabled && !registered) {
+      context.registerReceiver(noisyAudioStreamReceiver, intentFilter)
+      registered = true
+    } else if (!enabled && registered) {
+      context.unregisterReceiver(noisyAudioStreamReceiver)
+      registered = false
+    }
+  }
+}