react-native-theoplayer 1.8.2 → 2.0.0

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

@@ -0,0 +1,178 @@
+package com.theoplayer.player
+
+import com.facebook.react.bridge.*
+import com.theoplayer.*
+import com.theoplayer.abr.ABRConfigurationAdapter
+import com.theoplayer.android.api.player.PreloadType
+import com.theoplayer.android.api.player.PresentationMode
+import com.theoplayer.android.api.player.track.mediatrack.MediaTrack
+import com.theoplayer.android.api.player.track.mediatrack.quality.VideoQuality
+import com.theoplayer.android.api.player.track.texttrack.TextTrackMode
+import com.theoplayer.audio.BackgroundAudioConfigAdapter
+import com.theoplayer.presentation.PipConfigAdapter
+import com.theoplayer.track.QualityListFilter
+import com.theoplayer.track.emptyQualityList
+import com.theoplayer.util.ViewResolver
+
+private const val TAG = "PlayerModule"
+
+class PlayerModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+  private val viewResolver: ViewResolver
+
+  init {
+    viewResolver = ViewResolver(context)
+  }
+
+  override fun getName(): String {
+    return TAG
+  }
+
+  @ReactMethod
+  fun setABRConfig(tag: Int, config: ReadableMap?) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      ABRConfigurationAdapter.applyABRConfigurationFromProps(view?.player, config)
+    }
+  }
+
+  @ReactMethod
+  fun setSource(tag: Int, src: ReadableMap?) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.setSource(src)
+    }
+  }
+
+  @ReactMethod
+  fun setCurrentTime(tag: Int, time: Double) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.player?.currentTime = 1e-03 * time
+    }
+  }
+
+  @ReactMethod
+  fun setPaused(tag: Int, paused: Boolean) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      if (paused) {
+        view?.player?.pause()
+      } else {
+        view?.player?.play()
+      }
+    }
+  }
+
+  @ReactMethod
+  fun setMuted(tag: Int, muted: Boolean) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.player?.isMuted = muted
+    }
+  }
+
+  @ReactMethod
+  fun setVolume(tag: Int, volume: Double) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.player?.volume = volume
+    }
+  }
+
+  @ReactMethod
+  fun setPlaybackRate(tag: Int, playbackRate: Double) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.player?.playbackRate = playbackRate
+    }
+  }
+
+  @ReactMethod
+  fun setSelectedTextTrack(tag: Int, uid: Int) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.player?.let {
+        for (track in it.textTracks) {
+          if (track.uid == uid) {
+            track.mode = TextTrackMode.SHOWING
+          } else if (track.mode == TextTrackMode.SHOWING) {
+            track.mode = TextTrackMode.DISABLED
+          }
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun setSelectedAudioTrack(tag: Int, uid: Int) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.player?.let {
+        for (track in it.audioTracks) {
+          track.isEnabled = track.uid == uid
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun setSelectedVideoTrack(tag: Int, uid: Int) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.player?.let {
+        for (track in it.videoTracks) {
+          track.isEnabled = track.uid == uid
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun setTargetVideoQuality(tag: Int, uids: ReadableArray) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.player?.let {
+        // Apply the target quality to the current enabled video track
+        for (track in it.videoTracks) {
+          if (track.isEnabled) {
+            val currentVideoTrack = track as MediaTrack<VideoQuality>
+            if (uids.size() == 0) {
+              // Reset target qualities when passing empty list.
+              currentVideoTrack.targetQualities = emptyQualityList()
+              currentVideoTrack.targetQuality = null
+            } else {
+              currentVideoTrack.qualities?.let { qualities ->
+                currentVideoTrack.targetQualities = QualityListFilter(qualities).filterQualityList(uids)
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun setPreload(tag: Int, type: String?) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.player?.preload = when (type) {
+        "auto" -> PreloadType.AUTO
+        "metadata" -> PreloadType.METADATA
+        else -> PreloadType.NONE
+      }
+    }
+  }
+
+  @ReactMethod
+  fun setPresentationMode(tag: Int, type: String?) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.presentationManager?.setPresentation(when (type) {
+        "picture-in-picture" -> PresentationMode.PICTURE_IN_PICTURE
+        "fullscreen" -> PresentationMode.FULLSCREEN
+        else -> PresentationMode.INLINE
+      })
+    }
+  }
+
+  @ReactMethod
+  fun setPipConfig(tag: Int, config: ReadableMap?) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.presentationManager?.pipConfig = PipConfigAdapter.fromProps(config)
+    }
+  }
+
+  @ReactMethod
+  fun setBackgroundAudioConfig(tag: Int, config: ReadableMap) {
+    viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+      view?.playerContext?.backgroundAudioConfig = BackgroundAudioConfigAdapter.fromProps(config)
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/presentation/PipConfig.kt

@@ -0,0 +1,10 @@
+package com.theoplayer.presentation
+
+data class PipConfig(
+  /**
+   * Set whether the app should transition to PiP automatically when going to the background.
+   *
+   * @defaultValue `false`
+   */
+  val startsAutomatically: Boolean? = false
+)

package/android/src/main/java/com/theoplayer/presentation/PipConfigAdapter.kt

@@ -0,0 +1,14 @@
+package com.theoplayer.presentation
+
+import com.facebook.react.bridge.ReadableMap
+
+object PipConfigAdapter {
+
+  private const val PROP_AUTO = "startsAutomatically"
+
+  fun fromProps(configProps: ReadableMap?): PipConfig {
+    return PipConfig(
+      if (configProps?.hasKey(PROP_AUTO) == true) configProps.getBoolean(PROP_AUTO) else false
+    )
+  }
+}

package/android/src/main/java/com/theoplayer/presentation/PresentationManager.kt

@@ -0,0 +1,249 @@
+package com.theoplayer.presentation
+
+import android.app.AppOpsManager
+import android.app.PictureInPictureParams
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import android.graphics.Rect
+import android.os.Build
+import android.util.Rational
+import android.view.SurfaceView
+import android.view.TextureView
+import android.view.View
+import android.view.ViewGroup
+import androidx.activity.ComponentActivity
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import androidx.lifecycle.Lifecycle
+import com.facebook.react.uimanager.ThemedReactContext
+import com.theoplayer.PlayerEventEmitter
+import com.theoplayer.ReactTHEOplayerContext
+import com.theoplayer.android.api.error.ErrorCode
+import com.theoplayer.android.api.error.THEOplayerException
+import com.theoplayer.android.api.player.PresentationMode
+
+private val PIP_ASPECT_RATIO_DEFAULT = Rational(16, 9)
+private val PIP_ASPECT_RATIO_MIN = Rational(100, 239)
+private val PIP_ASPECT_RATIO_MAX = Rational(239, 100)
+
+class PresentationManager(
+  private val viewCtx: ReactTHEOplayerContext,
+  private val reactContext: ThemedReactContext,
+  private val eventEmitter: PlayerEventEmitter,
+) {
+  private var supportsPip = false
+  private var onUserLeaveHintReceiver: BroadcastReceiver? = null
+  private var onPictureInPictureModeChanged: BroadcastReceiver? = null
+
+  var currentPresentationMode: PresentationMode = PresentationMode.INLINE
+    private set
+
+  var pipConfig: PipConfig = PipConfig()
+
+  init {
+    onUserLeaveHintReceiver = object : BroadcastReceiver() {
+      override fun onReceive(context: Context?, intent: Intent?) {
+        // Optionally into PiP mode when the app goes to background.
+        if (pipConfig.startsAutomatically == true) {
+          setPresentation(PresentationMode.PICTURE_IN_PICTURE)
+        }
+      }
+    }
+    onPictureInPictureModeChanged = object : BroadcastReceiver() {
+      override fun onReceive(context: Context?, intent: Intent?) {
+        // Dispatch event on every PiP mode change
+        val inPip = intent?.getBooleanExtra("isInPictureInPictureMode", false) ?: false
+        if (inPip) {
+          updatePresentationMode(PresentationMode.PICTURE_IN_PICTURE)
+        } else {
+          val pipCtx: PresentationModeChangePipContext = if ((reactContext.currentActivity as? ComponentActivity)
+            ?.lifecycle?.currentState == Lifecycle.State.CREATED) {
+            PresentationModeChangePipContext.CLOSED
+          } else {
+            PresentationModeChangePipContext.RESTORED
+          }
+          updatePresentationMode(PresentationMode.INLINE, PresentationModeChangeContext(pipCtx))
+        }
+      }
+    }
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      supportsPip =
+        reactContext.packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)
+    }
+    reactContext.currentActivity?.registerReceiver(
+      onUserLeaveHintReceiver, IntentFilter("onUserLeaveHint")
+    )
+    reactContext.currentActivity?.registerReceiver(
+      onPictureInPictureModeChanged, IntentFilter("onPictureInPictureModeChanged")
+    )
+  }
+
+  /**
+   * Whether playback should be allowed to continue when the activity is paused.
+   *
+   * Pause if:
+   * - No PiP available: Build.VERSION.SDK_INT < Build.VERSION_CODES.N (API 24), or;
+   * - Not in PiP mode, and;
+   * - Not configured to automatically go into PiP when going to the background.
+   */
+  val shouldPauseOnHostPause: Boolean
+    get() = Build.VERSION.SDK_INT < Build.VERSION_CODES.N ||
+      (reactContext.currentActivity?.isInPictureInPictureMode != true && pipConfig.startsAutomatically != true)
+
+  fun destroy() {
+    try {
+      reactContext.currentActivity?.unregisterReceiver(onUserLeaveHintReceiver)
+      reactContext.currentActivity?.unregisterReceiver(onPictureInPictureModeChanged)
+    } catch (ignore: Exception) {
+    }
+  }
+
+  fun setPresentation(mode: PresentationMode) {
+    when (mode) {
+      PresentationMode.INLINE -> {
+        setFullscreen(false)
+      }
+      PresentationMode.FULLSCREEN -> {
+        setFullscreen(true)
+      }
+      PresentationMode.PICTURE_IN_PICTURE -> {
+        setFullscreen(false)
+        enterPip()
+      }
+    }
+  }
+
+  private fun getContentViewRect(view: ViewGroup): Rect? {
+    for (i in 0 until view.childCount) {
+      val child: View = view.getChildAt(i)
+      if (child is ViewGroup) {
+        return getContentViewRect(child)
+      } else if (child as? SurfaceView != null || child as? TextureView != null) {
+        val visibleRect = Rect()
+        child.getGlobalVisibleRect(visibleRect)
+        return visibleRect
+      }
+    }
+    return null
+  }
+
+  private fun enterPip() {
+    // PiP not supported
+    if (!supportsPip || Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      return
+    }
+
+    // Already in right PiP state?
+    if (currentPresentationMode == PresentationMode.PICTURE_IN_PICTURE) {
+      return
+    }
+
+    // Check to see whether this activity is in the process of finishing, either because you
+    // called finish on it or someone else has requested that it finished.
+    if (reactContext.currentActivity?.isFinishing == true) {
+      return
+    }
+
+    // Check whether the special permission Picture-in-Picture is given.
+    if (!hasPipPermission()) {
+      return
+    }
+
+    try {
+      val view = viewCtx.playerView
+      val visibleRect = getContentViewRect(view)
+      reactContext.currentActivity?.enterPictureInPictureMode(
+        PictureInPictureParams.Builder().setSourceRectHint(visibleRect)
+          // Must be between 2.39:1 and 1:2.39 (inclusive)
+          .setAspectRatio(getSafeAspectRatio(view.player.videoWidth, view.player.videoHeight))
+          // The active MediaSession will connect the controls
+          .build()
+      )
+    } catch (_: Exception) {
+      onPipError()
+    }
+  }
+
+  private fun getSafeAspectRatio(width: Int, height: Int): Rational {
+    val aspectRatio = Rational(width, height)
+    if (aspectRatio.isNaN || aspectRatio.isInfinite || aspectRatio.isZero) {
+      // Default aspect ratio
+      return PIP_ASPECT_RATIO_DEFAULT
+    }
+    if (aspectRatio > PIP_ASPECT_RATIO_MAX) {
+      return PIP_ASPECT_RATIO_MAX
+    }
+    if (aspectRatio < PIP_ASPECT_RATIO_MIN) {
+      return PIP_ASPECT_RATIO_MIN
+    }
+    return aspectRatio
+  }
+
+  private fun hasPipPermission(): Boolean {
+    val appOps = reactContext.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager?
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        appOps?.unsafeCheckOpNoThrow(
+          AppOpsManager.OPSTR_PICTURE_IN_PICTURE,
+          reactContext.applicationInfo.uid,
+          reactContext.packageName
+        ) == AppOpsManager.MODE_ALLOWED
+      } else {
+        @Suppress("DEPRECATION")
+        appOps?.checkOpNoThrow(
+          AppOpsManager.OPSTR_PICTURE_IN_PICTURE,
+          reactContext.applicationInfo.uid,
+          reactContext.packageName
+        ) == AppOpsManager.MODE_ALLOWED
+      }
+    } else {
+      false
+    }
+  }
+
+  private fun onPipError() {
+    val message = "Failed to enter picture-in-picture mode."
+    eventEmitter.emitError(THEOplayerException(ErrorCode.CONFIGURATION_ERROR, message))
+  }
+
+  private fun setFullscreen(fullscreen: Boolean) {
+    if ((fullscreen && currentPresentationMode == PresentationMode.FULLSCREEN) ||
+      (!fullscreen && currentPresentationMode == PresentationMode.INLINE)
+    ) {
+      return
+    }
+    val activity = reactContext.currentActivity ?: return
+    val window = activity.window
+    if (fullscreen) {
+      WindowInsetsControllerCompat(window, window.decorView).apply {
+        systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+      }.hide(WindowInsetsCompat.Type.systemBars())
+      updatePresentationMode(PresentationMode.FULLSCREEN)
+    } else {
+      WindowInsetsControllerCompat(window, window.decorView).show(
+        WindowInsetsCompat.Type.systemBars()
+      )
+      updatePresentationMode(PresentationMode.INLINE)
+    }
+  }
+
+  private fun updatePresentationMode(
+    presentationMode: PresentationMode,
+    context: PresentationModeChangeContext? = null
+  ) {
+    if (presentationMode == currentPresentationMode) {
+      return
+    }
+    val prevPresentationMode = currentPresentationMode
+    currentPresentationMode = presentationMode
+    eventEmitter.emitPresentationModeChange(presentationMode, prevPresentationMode, context)
+
+    // Apply background audio config when closing PiP window
+    if (context?.pip == PresentationModeChangePipContext.CLOSED && !viewCtx.backgroundAudioConfig.enabled) {
+      viewCtx.player.pause()
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/presentation/PresentationModeChangeContext.kt

@@ -0,0 +1,17 @@
+package com.theoplayer.presentation
+
+/**
+ * Provide information on how the PiP window transitioned.
+ */
+enum class PresentationModeChangePipContext {
+
+  // The PiP window was closed.
+  CLOSED,
+
+  // The PiP window transitioned back into the app.
+  RESTORED
+}
+
+data class PresentationModeChangeContext(
+  val pip: PresentationModeChangePipContext?
+)

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

@@ -62,7 +62,10 @@ class SourceAdapter {
   private val gson = Gson()
 
   @Throws(THEOplayerException::class)
-  fun parseSourceFromJS(source: ReadableMap): SourceDescription? {
+  fun parseSourceFromJS(source: ReadableMap?): SourceDescription? {
+    if (source == null) {
+      return null
+    }
     val hashmap = eliminateReadables(source)
     try {
       val json = gson.toJson(hashmap)
@@ -81,7 +84,8 @@ class SourceAdapter {
           }
         }
       } else {
-        val typedSource = parseTypedSource(jsonSourceObject.getJSONObject(PROP_SOURCES))
+        val jsonSource = jsonSourceObject.optJSONObject(PROP_SOURCES) ?: return null
+        val typedSource = parseTypedSource(jsonSource)
         if (typedSource != null) {
           typedSources.add(typedSource)
         }

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

@@ -4,12 +4,20 @@ import com.theoplayer.android.api.player.track.mediatrack.quality.Quality
 import com.theoplayer.android.api.player.track.mediatrack.quality.QualityList
 import java.util.*
 
+fun <Q: Quality> emptyQualityList(): QualityList<Q>  {
+  return QualityListAdapter()
+}
+
 /**
  * Adapts an Android List to a QualityList.
  */
 class QualityListAdapter<Q : Quality> : QualityList<Q> {
   private var qualities: MutableList<Q>
 
+  constructor() {
+    this.qualities = arrayListOf()
+  }
+
   constructor(qualities: MutableList<Q>) {
     this.qualities = qualities
   }

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

@@ -2,7 +2,9 @@ package com.theoplayer.track
 
 enum class TextTrackCueEventType(val type: Int) {
   ADD_CUE(0),
-  REMOVE_CUE(1);
+  REMOVE_CUE(1),
+  ENTER_CUE(2),
+  EXIT_CUE(3);
 
   fun type(): Int {
     return this.type

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

@@ -27,21 +27,20 @@ private const val PROP_AUDIO_SAMPLING_RATE = "audioSamplingRate"
 private const val PROP_BANDWIDTH = "bandwidth"
 private const val PROP_QUALITIES = "qualities"
 private const val PROP_ACTIVE_QUALITY = "activeQuality"
-private const val PROP_TARGET_QUALITY = "targetQuality"
 private const val PROP_WIDTH = "width"
 private const val PROP_HEIGHT = "height"
-private const val PROP_FRAMERATE = "framerate"
+private const val PROP_FRAMERATE = "frameRate"
 private const val PROP_STARTTIME = "startTime"
 private const val PROP_ENDTIME = "endTime"
 private const val PROP_CUES = "cues"
 private const val PROP_CUE_CONTENT = "content"
 
-class TrackListAdapter {
+object TrackListAdapter {
 
-  fun fromTextTrackList(textTrackList: TextTrackList): WritableArray {
+  fun fromTextTrackList(textTrackList: TextTrackList?): WritableArray {
     val textTracks = Arguments.createArray()
-    for (i in 0 until textTrackList.length()) {
-      textTracks.pushMap(fromTextTrack(textTrackList.getItem(i)))
+    textTrackList?.forEach { track ->
+      textTracks.pushMap(fromTextTrack(track))
     }
     return textTracks
   }
@@ -76,11 +75,14 @@ class TrackListAdapter {
     val cuePayload = Arguments.createMap()
     cuePayload.putString(PROP_ID, cue.id)
     cuePayload.putDouble(PROP_UID, cue.uid.toDouble())
-    cuePayload.putDouble(PROP_STARTTIME, (1e03 * cue.startTime).toLong().toDouble())
-    cuePayload.putDouble(PROP_ENDTIME, (1e03 * cue.endTime).toLong().toDouble())
+    cuePayload.putDouble(PROP_STARTTIME, (1e3 * cue.startTime).toLong().toDouble())
+    cuePayload.putDouble(PROP_ENDTIME, (1e3 * cue.endTime).toLong().toDouble())
     val content = cue.content
     if (content != null) {
-      cuePayload.putString(PROP_CUE_CONTENT, content.optString("content"))
+      cuePayload.putString(
+        PROP_CUE_CONTENT,
+        content.optString("content") ?: content.optString("contentString")
+      )
     }
     return cuePayload
   }
@@ -103,6 +105,7 @@ class TrackListAdapter {
     return audioQualityPayload
   }
 
+  @Suppress("UNCHECKED_CAST")
   fun <Q : Quality?> fromMediaTrack(
     track: MediaTrack<Q>,
     trackType: MediaTrackType
@@ -120,37 +123,21 @@ class TrackListAdapter {
     audioTrackPayload.putString(PROP_LANGUAGE, audioTrack.language)
     val qualityList = audioTrack.qualities
     val qualities = Arguments.createArray()
-    if (qualityList != null) {
-      for (j in 0 until qualityList.length()) {
-        qualities.pushMap(fromAudioQuality(qualityList.getItem(j)))
-      }
+    qualityList?.forEach { quality ->
+      qualities.pushMap(fromAudioQuality(quality))
     }
     audioTrackPayload.putArray(PROP_QUALITIES, qualities)
-    val targetQualityList = audioTrack.targetQualities
-    val targetQualities = Arguments.createArray()
-    if (targetQualityList != null) {
-      for (j in 0 until targetQualityList.length()) {
-        val quality = targetQualityList.getItem(j)
-        val audioQualityPayload = Arguments.createMap()
-        audioQualityPayload.putInt(PROP_UID, quality.uid)
-        targetQualities.pushMap(audioQualityPayload)
-      }
-    }
     val activeQuality = audioTrack.activeQuality
     if (activeQuality != null) {
-      audioTrackPayload.putInt(PROP_ACTIVE_QUALITY, activeQuality.uid)
-    }
-    val targetQuality = audioTrack.targetQuality
-    if (targetQuality != null) {
-      audioTrackPayload.putInt(PROP_TARGET_QUALITY, targetQuality.uid)
+      audioTrackPayload.putMap(PROP_ACTIVE_QUALITY, fromQuality(activeQuality))
     }
     return audioTrackPayload
   }
 
-  fun fromAudioTrackList(audioTrackList: MediaTrackList<AudioQuality>): WritableArray {
+  fun fromAudioTrackList(audioTrackList: MediaTrackList<AudioQuality>?): WritableArray {
     val audioTracks = Arguments.createArray()
-    for (i in 0 until audioTrackList.length()) {
-      audioTracks.pushMap(fromAudioTrack(audioTrackList.getItem(i)))
+    audioTrackList?.forEach { track ->
+      audioTracks.pushMap(fromAudioTrack(track))
     }
     return audioTracks
   }
@@ -188,31 +175,17 @@ class TrackListAdapter {
       }
     }
     videoTrackPayload.putArray(PROP_QUALITIES, qualities)
-    val targetQualityList = videoTrack.targetQualities
-    val targetQualities = Arguments.createArray()
-    if (targetQualityList != null) {
-      for (j in 0 until targetQualityList.length()) {
-        val quality = targetQualityList.getItem(j)
-        val videoQualityPayload = Arguments.createMap()
-        videoQualityPayload.putInt(PROP_UID, quality.uid)
-        targetQualities.pushMap(videoQualityPayload)
-      }
-    }
     val activeQuality = videoTrack.activeQuality
     if (activeQuality != null) {
-      videoTrackPayload.putInt(PROP_ACTIVE_QUALITY, activeQuality.uid)
-    }
-    val targetQuality = videoTrack.targetQuality
-    if (targetQuality != null) {
-      videoTrackPayload.putInt(PROP_TARGET_QUALITY, targetQuality.uid)
+      videoTrackPayload.putMap(PROP_ACTIVE_QUALITY, fromQuality(activeQuality))
     }
     return videoTrackPayload
   }
 
-  fun fromVideoTrackList(videoTrackList: MediaTrackList<VideoQuality>): WritableArray {
+  fun fromVideoTrackList(videoTrackList: MediaTrackList<VideoQuality>?): WritableArray {
     val videoTracks = Arguments.createArray()
-    for (i in 0 until videoTrackList.length()) {
-      videoTracks.pushMap(fromVideoTrack(videoTrackList.getItem(i)))
+    videoTrackList?.forEach { track ->
+      videoTracks.pushMap(fromVideoTrack(track))
     }
     return videoTracks
   }