react-native-theoplayer 1.7.1 → 1.8.0

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

@@ -0,0 +1,161 @@
+package com.theoplayer.ads
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableArray
+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 java.lang.Exception
+
+private const val PROP_AD_SYSTEM = "adSystem"
+private const val PROP_AD_INTEGRATION = "integration"
+private const val PROP_AD_TYPE = "type"
+private const val PROP_AD_ID = "id"
+private const val PROP_AD_BREAK = "adBreak"
+private const val PROP_AD_COMPANIONS = "companions"
+private const val PROP_AD_SKIPOFFSET = "skipOffset"
+private const val PROP_AD_CREATIVE_ID = "creativeId"
+private const val PROP_AD_TRAFFICKING_PARAMETERS = "traffickingParametersString"
+private const val PROP_AD_BITRATE = "bitrate"
+private const val PROP_AD_UNIVERSAL_AD_IDS = "universalAdIds"
+private const val PROP_AD_TITLE = "title"
+private const val PROP_AD_DURATION = "duration"
+private const val PROP_AD_WRAPPER_AD_IDS = "wrapperAdIds"
+private const val PROP_AD_WRAPPER_AD_SYSTEMS = "wrapperAdSystems"
+private const val PROP_AD_WRAPPER_CREATIVE_IDS = "wrapperCreativeIds"
+private const val PROP_AD_WIDTH = "width"
+private const val PROP_AD_HEIGHT = "height"
+private const val PROP_AD_CONTENT_TYPE = "contentType"
+private const val PROP_ADBREAK_INTEGRATION = "integration"
+private const val PROP_ADBREAK_MAXDURATION = "maxDuration"
+private const val PROP_ADBREAK_TIMEOFFSET = "timeOffset"
+private const val PROP_ADBREAK_MAXREMAININGDURATION = "maxRemainingDuration"
+private const val PROP_ADBREAK_ADS = "ads"
+private const val PROP_COMPANION_ADSLOTID = "adSlotId"
+private const val PROP_COMPANION_ALTTEXT = "altText"
+private const val PROP_COMPANION_CLICKTHROUGH = "clickThrough"
+private const val PROP_COMPANION_WIDTH = "width"
+private const val PROP_COMPANION_HEIGHT = "height"
+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)
+  }
+
+  fun fromAds(ads: List<Ad>): WritableArray {
+    val payload = Arguments.createArray()
+    for (ad in ads) {
+      payload.pushMap(fromAd(ad, true))
+    }
+    return payload
+  }
+
+  private fun fromAd(ad: Ad, includeAdBreak: Boolean): WritableMap {
+    val adPayload = Arguments.createMap()
+    adPayload.putString(
+      PROP_AD_INTEGRATION, if (ad.integration != null) ad.integration!!
+        .type else ""
+    )
+    adPayload.putString(PROP_AD_TYPE, ad.type)
+    adPayload.putString(PROP_AD_ID, ad.id)
+    val adBreak = ad.adBreak
+    if (includeAdBreak && adBreak != null) {
+      adPayload.putMap(PROP_AD_BREAK, fromAdBreak(adBreak))
+    }
+    adPayload.putArray(PROP_AD_COMPANIONS, fromCompanions(ad.companions))
+    adPayload.putInt(PROP_AD_SKIPOFFSET, ad.skipOffset)
+    if (ad is GoogleImaAd) {
+      adPayload.putString(PROP_AD_SYSTEM, ad.adSystem)
+      adPayload.putString(PROP_AD_CREATIVE_ID, ad.creativeId)
+      adPayload.putString(PROP_AD_TRAFFICKING_PARAMETERS, ad.traffickingParameters)
+      adPayload.putInt(PROP_AD_BITRATE, ad.vastMediaBitrate)
+      try {
+        adPayload.putString(PROP_AD_TITLE, ad.imaAd.title)
+        adPayload.putInt(PROP_AD_DURATION, (1e3 * ad.imaAd.duration).toInt())
+        adPayload.putDouble(PROP_AD_WIDTH, ad.imaAd.vastMediaWidth.toDouble())
+        adPayload.putDouble(PROP_AD_HEIGHT, ad.imaAd.vastMediaHeight.toDouble())
+        adPayload.putString(PROP_AD_CONTENT_TYPE, ad.imaAd.contentType)
+      } catch (ignore: Exception) {
+        // googleImaAd.getImaAd() is not known yet
+      }
+      val universalAdIdsPayload = Arguments.createArray()
+      for (universalAdId in ad.universalAdIds) {
+        val idPayload = Arguments.createMap()
+        idPayload.putString(
+          PROP_UNIVERSAL_AD_ID_REGISTRY,
+          universalAdId.universalAdIdRegistry
+        )
+        idPayload.putString(PROP_UNIVERSAL_AD_ID_VALUE, universalAdId.universalAdIdValue)
+        universalAdIdsPayload.pushMap(idPayload)
+      }
+      adPayload.putArray(PROP_AD_UNIVERSAL_AD_IDS, universalAdIdsPayload)
+      val wrapperAdIdsPayload = Arguments.createArray()
+      for (wrapperAdId in ad.wrapperAdIds) {
+        wrapperAdIdsPayload.pushString(wrapperAdId)
+      }
+      adPayload.putArray(PROP_AD_WRAPPER_AD_IDS, wrapperAdIdsPayload)
+      val wrapperAdSystemsPayload = Arguments.createArray()
+      for (wrapperAdSystem in ad.wrapperAdSystems) {
+        wrapperAdSystemsPayload.pushString(wrapperAdSystem)
+      }
+      adPayload.putArray(PROP_AD_WRAPPER_AD_SYSTEMS, wrapperAdSystemsPayload)
+      val wrapperCreativeIdsPayload = Arguments.createArray()
+      for (wrapperCreativeId in ad.wrapperCreativeIds) {
+        wrapperCreativeIdsPayload.pushString(wrapperCreativeId)
+      }
+      adPayload.putArray(PROP_AD_WRAPPER_CREATIVE_IDS, wrapperCreativeIdsPayload)
+    }
+    return adPayload
+  }
+
+  fun fromAdBreak(adbreak: AdBreak?): WritableMap {
+    val adbreakPayload = Arguments.createMap()
+    if (adbreak == null) {
+      return adbreakPayload
+    }
+    adbreakPayload.putString(PROP_ADBREAK_INTEGRATION, adbreak.integration.type)
+    adbreakPayload.putInt(PROP_ADBREAK_MAXDURATION, (1e3 * adbreak.maxDuration).toInt())
+    adbreakPayload.putInt(PROP_ADBREAK_TIMEOFFSET, (1e3 * adbreak.timeOffset).toInt())
+    adbreakPayload.putInt(
+      PROP_ADBREAK_MAXREMAININGDURATION,
+      (1e3 * adbreak.maxRemainingDuration).toInt()
+    )
+    val adsPayload = Arguments.createArray()
+    for (ad in adbreak.ads) {
+      // Some ads in the ad break are possibly not loaded yet.
+      if (ad != null) {
+        adsPayload.pushMap(fromAd(ad, false))
+      }
+    }
+    adbreakPayload.putArray(PROP_ADBREAK_ADS, adsPayload)
+    return adbreakPayload
+  }
+
+  fun fromAdBreaks(adbreaks: List<AdBreak?>): WritableArray {
+    val payload = Arguments.createArray()
+    for (adbreak in adbreaks) {
+      payload.pushMap(fromAdBreak(adbreak))
+    }
+    return payload
+  }
+
+  private fun fromCompanions(companions: List<CompanionAd>): WritableArray {
+    val companionsPayload = Arguments.createArray()
+    for (companionAd in companions) {
+      val adPayload = Arguments.createMap()
+      adPayload.putString(PROP_COMPANION_ADSLOTID, companionAd.adSlotId)
+      adPayload.putString(PROP_COMPANION_ALTTEXT, companionAd.altText)
+      adPayload.putString(PROP_COMPANION_CLICKTHROUGH, companionAd.clickThrough)
+      adPayload.putInt(PROP_COMPANION_WIDTH, companionAd.width)
+      adPayload.putInt(PROP_COMPANION_HEIGHT, companionAd.height)
+      adPayload.putString(PROP_COMPANION_RESOURCEURI, companionAd.resourceURI)
+      companionsPayload.pushMap(adPayload)
+    }
+    return companionsPayload
+  }
+}

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

@@ -0,0 +1,90 @@
+package com.theoplayer.ads
+
+import com.facebook.react.bridge.Arguments
+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.ima.GoogleImaAdEventType
+import com.theoplayer.android.api.ads.wrapper.AdEventListener
+import com.theoplayer.android.api.event.EventType
+import com.theoplayer.android.api.event.ads.AdEvent
+import java.util.*
+
+private const val EVENT_PROP_AD = "ad"
+private const val EVENT_PROP_TYPE = "type"
+private val ALL_AD_EVENTS = arrayOf(
+  GoogleImaAdEventType.LOADED,
+  GoogleImaAdEventType.AD_BREAK_STARTED,
+  GoogleImaAdEventType.STARTED,
+  GoogleImaAdEventType.FIRST_QUARTILE,
+  GoogleImaAdEventType.MIDPOINT,
+  GoogleImaAdEventType.THIRD_QUARTILE,
+  GoogleImaAdEventType.COMPLETED,
+  GoogleImaAdEventType.AD_BREAK_ENDED,
+  GoogleImaAdEventType.SKIPPED,
+  GoogleImaAdEventType.AD_ERROR,
+  GoogleImaAdEventType.AD_BUFFERING,
+  GoogleImaAdEventType.AD_BREAK_FETCH_ERROR
+)
+
+class AdEventAdapter(private val adsApi: AdsApiWrapper, eventEmitter: AdEventEmitter) {
+  private val eventListener: AdEventListener
+
+  interface AdEventEmitter {
+    fun emit(payload: WritableMap?)
+  }
+
+  init {
+    eventListener = object : AdEventListener {
+      override fun <E : AdEvent<*>?> onAdEvent(type: EventType<E>?, ad: Ad?) {
+        val payload = Arguments.createMap()
+        if (type != null) {
+          payload.putString(EVENT_PROP_TYPE, mapAdType(type))
+        }
+        if (ad != null) {
+          payload.putMap(EVENT_PROP_AD, AdAdapter.fromAd(ad))
+        }
+        eventEmitter.emit(payload)
+      }
+
+      override fun <E : AdEvent<*>?> onAdBreakEvent(type: EventType<E>?, adBreak: AdBreak?) {
+        val payload = Arguments.createMap()
+        if (type != null) {
+          payload.putString(EVENT_PROP_TYPE, mapAdType(type))
+        }
+        if (adBreak != null) {
+          payload.putMap(EVENT_PROP_AD, AdAdapter.fromAdBreak(adBreak))
+        }
+        eventEmitter.emit(payload)
+      }
+    }
+    for (eventType in ALL_AD_EVENTS) {
+      adsApi.addEventListener(eventType, eventListener)
+    }
+  }
+
+  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())
+    }
+  }
+
+  fun destroy() {
+    for (eventType in ALL_AD_EVENTS) {
+      adsApi.removeEventListener(eventType, eventListener)
+    }
+  }
+}

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

@@ -0,0 +1,140 @@
+@file:Suppress("unused")
+
+package com.theoplayer.ads
+
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.theoplayer.source.SourceAdapter
+import com.theoplayer.util.ViewResolver
+import com.theoplayer.ReactTHEOplayerView
+import com.theoplayer.android.api.error.THEOplayerException
+
+private const val TAG = "AdsModule"
+
+class AdsModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+  private val sourceHelper = SourceAdapter()
+  private val viewResolver: ViewResolver
+
+  init {
+    viewResolver = ViewResolver(context)
+  }
+
+  override fun getName(): String {
+    return TAG
+  }
+
+  // Add an ad break request.
+  @ReactMethod
+  fun schedule(tag: Int, ad: ReadableMap) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      if (view != null) {
+        try {
+          view.adsApi.schedule(sourceHelper.parseAdFromJS(ad))
+        } catch (exception: THEOplayerException) {
+          Log.e(TAG, exception.message!!)
+        }
+      }
+    }
+  }
+
+  // The currently playing ad break.
+  @ReactMethod
+  fun currentAdBreak(tag: Int, promise: Promise) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      if (view == null) {
+        promise.resolve(Arguments.createMap())
+      } else {
+        promise.resolve(AdAdapter.fromAdBreak(view.adsApi.currentAdBreak))
+      }
+    }
+  }
+
+  // List of currently playing ads.
+  @ReactMethod
+  fun currentAds(tag: Int, promise: Promise) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      if (view == null) {
+        promise.resolve(Arguments.createMap())
+      } else {
+        promise.resolve(AdAdapter.fromAds(view.adsApi.currentAds))
+      }
+    }
+  }
+
+  // List of ad breaks which still need to be played.
+  @ReactMethod
+  fun scheduledAdBreaks(tag: Int, promise: Promise) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      if (view == null) {
+        promise.resolve(Arguments.createMap())
+      } else {
+        promise.resolve(AdAdapter.fromAdBreaks(view.adsApi.scheduledAdBreaks))
+      }
+    }
+  }
+
+  // Whether a linear ad is currently playing.
+  @ReactMethod
+  fun playing(tag: Int, promise: Promise) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      if (view == null) {
+        promise.resolve(false)
+      } else {
+        promise.resolve(view.adsApi.isPlaying)
+      }
+    }
+  }
+
+  // Skip the current linear ad.
+  // NOTE: This will have no effect when the current linear ad is (not yet) skippable.
+  @ReactMethod
+  fun skip(tag: Int) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? -> view?.adsApi?.skip() }
+  }
+
+  @ReactMethod
+  fun daiSnapback(tag: Int, promise: Promise) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      val daiIntegration = view?.daiIntegration
+      if (daiIntegration == null) {
+        promise.resolve(false)
+      } else {
+        promise.resolve(daiIntegration.enableSnapback)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun daiSetSnapback(tag: Int, enabled: Boolean?) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      val daiIntegration = view?.daiIntegration
+      if (daiIntegration != null) {
+        daiIntegration.enableSnapback = enabled!!
+      }
+    }
+  }
+
+  @ReactMethod
+  fun daiContentTimeForStreamTime(tag: Int, time: Int, promise: Promise) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      val daiIntegration = view?.daiIntegration
+      if (daiIntegration == null) {
+        promise.resolve(time)
+      } else {
+        promise.resolve((1e03 * daiIntegration.contentTimeForStreamTime(1e-03 * time)).toInt())
+      }
+    }
+  }
+
+  @ReactMethod
+  fun daiStreamTimeForContentTime(tag: Int, time: Int, promise: Promise) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      val daiIntegration = view?.daiIntegration
+      if (daiIntegration == null) {
+        promise.resolve(time)
+      } else {
+        promise.resolve((1e03 * daiIntegration.streamTimeForContentTime(1e-03 * time)).toInt())
+      }
+    }
+  }
+}

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

@@ -0,0 +1,81 @@
+package com.theoplayer.cast
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+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.chromecast.CastErrorEvent
+import com.theoplayer.android.api.event.chromecast.CastStateChangeEvent
+import com.theoplayer.android.api.event.chromecast.ChromecastEventTypes
+
+const val EVENT_PROP_TYPE = "type"
+const val EVENT_PROP_STATE = "state"
+const val EVENT_PROP_ERROR = "error"
+const val EVENT_PROP_ERROR_CODE = "errorCode"
+const val EVENT_PROP_ERROR_DESCRIPTION = "description"
+
+class CastEventAdapter(private val castApi: Cast, private val emitter: Emitter) {
+
+  interface Emitter {
+    fun emit(payload: WritableMap?)
+  }
+
+  init {
+    castApi.chromecast.addEventListener(ChromecastEventTypes.ERROR, this::onCastError)
+    castApi.chromecast.addEventListener(ChromecastEventTypes.STATECHANGE, this::onStateChange)
+  }
+
+  fun destroy() {
+    castApi.chromecast.removeEventListener(ChromecastEventTypes.ERROR, this::onCastError)
+    castApi.chromecast.removeEventListener(ChromecastEventTypes.STATECHANGE, this::onStateChange)
+  }
+
+  private fun onCastError(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  {
+    val errorPayload = Arguments.createMap()
+    errorPayload.putString(
+      EVENT_PROP_ERROR_CODE,
+      when (error.errorCode) {
+        ErrorCode.CANCEL -> "CANCEL"
+        ErrorCode.TIMEOUT -> "TIMEOUT"
+        ErrorCode.API_NOT_INITIALIZED -> "API_NOT_INITIALIZED"
+        ErrorCode.INVALID_PARAMETER -> "INVALID_PARAMETER"
+        ErrorCode.EXTENSION_NOT_COMPATIBLE -> "EXTENSION_NOT_COMPATIBLE"
+        ErrorCode.EXTENSION_MISSING -> "EXTENSION_MISSING"
+        ErrorCode.RECEIVER_UNAVAILABLE -> "RECEIVER_UNAVAILABLE"
+        ErrorCode.SESSION_ERROR -> "SESSION_ERROR"
+        ErrorCode.CHANNEL_ERROR -> "CHANNEL_ERROR"
+        ErrorCode.LOAD_MEDIA_FAILED -> "LOAD_MEDIA_FAILED"
+        null -> ""
+      }
+    )
+    errorPayload.putString(EVENT_PROP_ERROR_DESCRIPTION, error.description)
+    return errorPayload
+  }
+
+  private fun onStateChange(event: CastStateChangeEvent) {
+    val payload = Arguments.createMap()
+    payload.putString(EVENT_PROP_TYPE, "chromecaststatechange")
+    if (event.state != null) {
+      payload.putString(
+        EVENT_PROP_STATE,
+        when (event.state) {
+          PlayerCastState.UNAVAILABLE -> "unavailable"
+          PlayerCastState.AVAILABLE -> "available"
+          PlayerCastState.CONNECTING -> "connecting"
+          PlayerCastState.CONNECTED -> "connected"
+          null -> "unavailable"
+        }
+      )
+    }
+    emitter.emit(payload)
+  }
+}

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

@@ -0,0 +1,75 @@
+@file:Suppress("unused")
+package com.theoplayer.cast
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.theoplayer.util.ViewResolver
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import com.theoplayer.ReactTHEOplayerView
+import com.theoplayer.android.api.cast.chromecast.PlayerCastState
+
+class CastModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+  private val viewResolver: ViewResolver = ViewResolver(context)
+
+  override fun getName(): String {
+    return "CastModule"
+  }
+
+  @ReactMethod
+  fun casting(tag: Int, promise: Promise) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      promise.resolve(view?.castIntegration?.isCasting() ?: false)
+    }
+  }
+
+  @ReactMethod
+  fun chromecastCasting(tag: Int, promise: Promise) {
+    casting(tag, promise)
+  }
+
+  @ReactMethod
+  fun chromecastState(tag: Int, promise: Promise) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      promise.resolve(castStateToString(view?.castIntegration?.getState() ?: PlayerCastState.UNAVAILABLE))
+    }
+  }
+
+  private fun castStateToString(state: PlayerCastState): String {
+    return when (state) {
+      PlayerCastState.AVAILABLE -> "available"
+      PlayerCastState.CONNECTED -> "connected"
+      PlayerCastState.CONNECTING -> "connecting"
+      PlayerCastState.UNAVAILABLE -> "unavailable"
+      else -> "unavailable"
+    }
+  }
+
+  @ReactMethod
+  fun chromecastStart(tag: Int) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.castIntegration?.start()
+    }
+  }
+
+  @ReactMethod
+  fun chromecastStop(tag: Int) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.castIntegration?.stop()
+    }
+  }
+
+  @ReactMethod
+  fun chromecastJoin(tag: Int) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.castIntegration?.join()
+    }
+  }
+
+  @ReactMethod
+  fun chromecastLeave(tag: Int) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.castIntegration?.leave()
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/drm/ContentProtectionAdapter.kt

@@ -15,6 +15,8 @@ import com.theoplayer.android.api.source.drm.KeySystemConfiguration
 import com.theoplayer.android.api.source.drm.preintegration.*
 import org.json.JSONObject
 
+private const val TAG = "ContentProtection"
+
 const val PROP_INTEGRATION: String = "integration"
 const val PROP_INTEGRATION_ID: String = "integrationId"
 const val PROP_INTEGRATION_PARAMETERS: String = "integrationParameters"
@@ -34,8 +36,6 @@ const val PROP_USE_CREDENTIALS: String = "useCredentials"
 
 object ContentProtectionAdapter {
 
-  const val TAG = "ContentProtection"
-
   private fun createBridgeData(integrationId: String, keySystemId: KeySystemId): WritableMap {
     return Arguments.createMap().apply {
       putString(PROP_INTEGRATION_ID, integrationId)

package/android/src/main/java/com/theoplayer/drm/ContentProtectionModule.kt

@@ -12,7 +12,6 @@ import com.theoplayer.android.api.contentprotection.*
 import com.theoplayer.android.api.error.ErrorCode
 import com.theoplayer.android.api.error.THEOplayerException
 import com.theoplayer.android.api.source.drm.DRMConfiguration
-import com.theoplayer.drm.ContentProtectionAdapter.fromDRMConfiguration
 
 data class BridgeRequest(
   val onResult: HashMap<String, (result: ReadableMap) -> Unit>,
@@ -108,7 +107,7 @@ class ContentProtectionModule(private val context: ReactApplicationContext) :
   fun onBuild(integrationId: String, keySystemId: KeySystemId, config: DRMConfiguration?) {
     val payload = createBridgeData(integrationId, keySystemId)
     if (config != null) {
-      payload.putMap(PROP_DRM_CONFIG, fromDRMConfiguration(config))
+      payload.putMap(PROP_DRM_CONFIG, ContentProtectionAdapter.fromDRMConfiguration(config))
     }
     emit(
       EVENT_BUILD_INTEGRATION, payload,

package/android/src/main/java/com/theoplayer/drm/ProxyContentProtectionIntegration.kt

@@ -8,8 +8,7 @@ class ProxyContentProtectionIntegration(
   private val keySystemId: KeySystemId,
   config: DRMConfiguration?,
   private val module: ContentProtectionModule
-) :
-  ContentProtectionIntegration() {
+) : ContentProtectionIntegration() {
 
   init {
     module.onBuild(integrationId, keySystemId, config)

package/android/src/main/java/com/theoplayer/drm/ProxyContentProtectionIntegrationFactory.kt

@@ -9,11 +9,9 @@ class ProxyContentProtectionIntegrationFactory(
   private val integrationId: String,
   private val keySystemId: KeySystemId,
   private val module: ContentProtectionModule
-) :
-  ContentProtectionIntegrationFactory {
-  override fun build(
-    config: DRMConfiguration?
-  ): ContentProtectionIntegration {
+) : ContentProtectionIntegrationFactory {
+
+  override fun build(config: DRMConfiguration?): ContentProtectionIntegration {
     return ProxyContentProtectionIntegration(integrationId, keySystemId, config, module)
   }
 }