spactureai-mobile-player 1.0.30

package/android/src/main/java/com/unifiedplayer/hybrids/videoplayer/HybridVideoPlayer.kt

@@ -0,0 +1,732 @@
+package com.margelo.nitro.unifiedplayer
+
+import android.graphics.Bitmap
+import android.media.MediaMetadataRetriever
+import android.os.Handler
+import android.os.Looper
+import android.util.Base64
+import android.util.Log
+import android.view.TextureView
+import java.io.ByteArrayOutputStream
+import androidx.media3.common.C
+import androidx.media3.common.Metadata
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.PlaybackParameters
+import androidx.media3.common.Player
+import androidx.media3.common.Tracks
+import androidx.media3.common.text.CueGroup
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultLoadControl
+import androidx.media3.exoplayer.DefaultRenderersFactory
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.analytics.AnalyticsListener
+import androidx.media3.exoplayer.mediacodec.MediaCodecSelector
+import androidx.media3.exoplayer.trackselection.DefaultTrackSelector
+import androidx.media3.exoplayer.upstream.DefaultAllocator
+import androidx.media3.extractor.metadata.emsg.EventMessage
+import androidx.media3.extractor.metadata.id3.Id3Frame
+import androidx.media3.extractor.metadata.id3.TextInformationFrame
+import androidx.media3.ui.PlayerView
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import com.unifiedplayer.core.LibraryError
+import com.unifiedplayer.core.PlayerError
+import com.unifiedplayer.core.VideoManager
+import com.unifiedplayer.core.extensions.startService
+import com.unifiedplayer.core.extensions.stopService
+import com.unifiedplayer.core.player.OnAudioFocusChangedListener
+import com.unifiedplayer.core.recivers.AudioBecomingNoisyReceiver
+import com.unifiedplayer.core.services.playback.VideoPlaybackService
+import com.unifiedplayer.core.services.playback.VideoPlaybackServiceConnection
+import com.unifiedplayer.core.utils.TextTrackUtils
+import com.unifiedplayer.core.utils.Threading.mainThreadProperty
+import com.unifiedplayer.core.utils.Threading.runOnMainThread
+import com.unifiedplayer.core.utils.Threading.runOnMainThreadSync
+import com.unifiedplayer.core.utils.VideoOrientationUtils
+import com.unifiedplayer.view.VideoView
+import java.lang.ref.WeakReference
+import kotlin.math.max
+
+@UnstableApi
+@DoNotStrip
+class HybridVideoPlayer() : HybridVideoPlayerSpec(), AutoCloseable {
+  override lateinit var source: HybridVideoPlayerSourceSpec
+  override var eventEmitter = HybridVideoPlayerEventEmitter()
+    set(value) {
+      if (field != value) {
+        audioFocusChangedListener.setEventEmitter(value)
+        audioBecomingNoisyReceiver.setEventEmitter(value)
+      }
+      field = value
+    }
+
+  private var allocator: DefaultAllocator? = null
+  private var context = NitroModules.applicationContext
+    ?: run {
+    throw LibraryError.ApplicationContextNotFound
+  }
+
+  var player: ExoPlayer = runOnMainThreadSync {
+    // Build Temporary player that will be replaced when source is loaded
+    return@runOnMainThreadSync ExoPlayer.Builder(context).build()
+  }
+
+  var loadedWithSource = false
+  private var currentPlayerView: WeakReference<PlayerView>? = null
+
+  var wasAutoPaused = false
+
+  // Buffer Config
+  private var bufferConfig: BufferConfig? = null
+    get() = source.config.bufferConfig
+
+  // Time updates
+  private val progressHandler = Handler(Looper.getMainLooper())
+  private var progressRunnable: Runnable? = null
+
+  // Listeners
+  private val audioFocusChangedListener = OnAudioFocusChangedListener()
+  private val audioBecomingNoisyReceiver = AudioBecomingNoisyReceiver()
+
+  // Service Connection
+  private val videoPlaybackServiceConnection = VideoPlaybackServiceConnection(WeakReference(this))
+
+  // Text track selection state
+  private var selectedExternalTrackIndex: Int? = null
+
+  private companion object {
+    const val PROGRESS_UPDATE_INTERVAL_MS = 250L
+    private const val TAG = "HybridVideoPlayer"
+    private const val DEFAULT_MIN_BUFFER_DURATION_MS = 5000
+    private const val DEFAULT_MAX_BUFFER_DURATION_MS = 10000
+    private const val DEFAULT_BUFFER_FOR_PLAYBACK_DURATION_MS = 1000
+    private const val DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_DURATION_MS = 2000
+    private const val DEFAULT_BACK_BUFFER_DURATION_MS = 0
+  }
+
+  override var status: VideoPlayerStatus = VideoPlayerStatus.IDLE
+    set(value) {
+      if (field != value) {
+        eventEmitter.onStatusChange(value)
+      }
+      field = value
+    }
+
+  override var showNotificationControls: Boolean = false
+    set(value) {
+      val wasRunning = (field || playInBackground)
+      val shouldRun = (value || playInBackground)
+
+      if (shouldRun && !wasRunning) {
+        VideoPlaybackService.startService(context, videoPlaybackServiceConnection)
+      }
+      if (!shouldRun && wasRunning) {
+        VideoPlaybackService.stopService(this, videoPlaybackServiceConnection)
+      }
+
+      field = value
+      // Inform service to refresh notification/session layout
+      try { videoPlaybackServiceConnection.serviceBinder?.service?.updatePlayerPreferences(this) } catch (_: Exception) {}
+    }
+
+  // Player Properties
+  override var currentTime: Double by mainThreadProperty(
+    get = { player.currentPosition.toDouble() / 1000.0 },
+    set = { value -> runOnMainThread { player.seekTo((value * 1000).toLong()) } }
+  )
+
+  // volume defined by user
+  var userVolume: Double = 1.0
+
+  override var volume: Double by mainThreadProperty(
+    get = { player.volume.toDouble() },
+    set = { value ->
+      userVolume = value
+      player.volume = value.toFloat()
+    }
+  )
+
+  override val duration: Double by mainThreadProperty(
+    get = {
+      val duration = player.duration
+      return@mainThreadProperty if (duration == C.TIME_UNSET) Double.NaN else duration.toDouble() / 1000.0
+    }
+  )
+
+  override var loop: Boolean by mainThreadProperty(
+    get = {
+      player.repeatMode == Player.REPEAT_MODE_ONE
+    },
+    set = { value ->
+      player.repeatMode = if (value) Player.REPEAT_MODE_ONE else Player.REPEAT_MODE_OFF
+    }
+  )
+
+  override var muted: Boolean by mainThreadProperty(
+    get = {
+      val playerVolume = player.volume.toDouble()
+      return@mainThreadProperty playerVolume == 0.0
+    },
+    set = { value ->
+      if (value) {
+        userVolume = volume
+        player.volume = 0f
+      } else {
+        player.volume = userVolume.toFloat()
+      }
+      eventEmitter.onVolumeChange(onVolumeChangeData(
+        volume = player.volume.toDouble(),
+        muted = muted
+      ))
+    }
+  )
+
+  override var rate: Double by mainThreadProperty(
+    get = { player.playbackParameters.speed.toDouble() },
+    set = { value ->
+      player.playbackParameters = player.playbackParameters.withSpeed(value.toFloat())
+    }
+  )
+
+  override var mixAudioMode: MixAudioMode = MixAudioMode.AUTO
+    set(value) {
+      VideoManager.audioFocusManager.requestAudioFocusUpdate()
+      field = value
+    }
+
+  // iOS only property
+  override var ignoreSilentSwitchMode: IgnoreSilentSwitchMode = IgnoreSilentSwitchMode.AUTO
+
+  override var playInBackground: Boolean = false
+    set(value) {
+      val shouldRun = (value || showNotificationControls)
+      val wasRunning = (field || showNotificationControls)
+
+      if (shouldRun && !wasRunning) {
+        VideoPlaybackService.startService(context, videoPlaybackServiceConnection)
+      }
+      if (!shouldRun && wasRunning) {
+        VideoPlaybackService.stopService(this, videoPlaybackServiceConnection)
+      }
+      field = value
+      // Update preferences to refresh notifications/registration
+      try { videoPlaybackServiceConnection.serviceBinder?.service?.updatePlayerPreferences(this) } catch (_: Exception) {}
+    }
+
+  override var playWhenInactive: Boolean = false
+
+  override var isPlaying: Boolean by mainThreadProperty(
+    get = { player.isPlaying == true }
+  )
+
+  private fun initializePlayer() {
+    if (NitroModules.applicationContext == null) {
+      throw LibraryError.ApplicationContextNotFound
+    }
+
+    val hybridSource = source as? HybridVideoPlayerSource ?: throw PlayerError.InvalidSource
+
+    // Initialize the allocator
+    allocator = DefaultAllocator(true, C.DEFAULT_BUFFER_SEGMENT_SIZE)
+
+    // Create a LoadControl with the allocator
+    val loadControl = DefaultLoadControl.Builder()
+      .setAllocator(allocator!!)
+      .setBufferDurationsMs(
+        bufferConfig?.minBufferMs?.toInt() ?: DEFAULT_MIN_BUFFER_DURATION_MS, // minBufferMs
+        bufferConfig?.maxBufferMs?.toInt() ?: DEFAULT_MAX_BUFFER_DURATION_MS, // maxBufferMs
+        bufferConfig?.bufferForPlaybackMs?.toInt()
+          ?: DEFAULT_BUFFER_FOR_PLAYBACK_DURATION_MS, // bufferForPlaybackMs
+        bufferConfig?.bufferForPlaybackAfterRebufferMs?.toInt()
+          ?: DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_DURATION_MS // bufferForPlaybackAfterRebufferMs
+      )
+      .setBackBuffer(
+        bufferConfig?.backBufferDurationMs?.toInt()
+          ?: DEFAULT_BACK_BUFFER_DURATION_MS, // backBufferDurationMs,
+        false // retainBackBufferFromKeyframe
+      )
+      .build()
+
+    // Renderers:
+    //   setEnableDecoderFallback(true) — if the primary HW decoder rejects an HEVC
+    //     sample (Main10, profile/level mismatch, vendor bug), ExoPlayer transparently
+    //     falls back to a secondary decoder (e.g. software c2.android.hevc.decoder).
+    //   setMediaCodecSelector(DEFAULT) — explicit so the selector enumerates *all*
+    //     HEVC decoders the device exposes, not just the first match. Some Mediatek
+    //     SoCs list a buggy HEVC HW decoder before the working one.
+    //   forceEnableMediaCodecAsynchronousQueueing() — kept; improves H.264 latency
+    //     and the decoder-fallback path will catch any device where async queueing
+    //     interacts badly with HEVC.
+    val renderersFactory = DefaultRenderersFactory(context)
+      .forceEnableMediaCodecAsynchronousQueueing()
+      .setEnableDecoderFallback(true)
+      .setMediaCodecSelector(MediaCodecSelector.DEFAULT)
+
+    // Track selector tuned for adaptive HLS that mixes H.264 and H.265 variants.
+    //   setAllowVideoMixedMimeTypeAdaptiveness — required to switch between H.264
+    //     and H.265 variants in the same EXT-X-STREAM-INF group. Off-by-default
+    //     conservatively, but server-side HEVC ladders often expose mixed MIME.
+    //   setAllowVideoNonSeamlessAdaptiveness — lets the player rebuild the codec
+    //     when crossing a HEVC variant boundary instead of failing track selection.
+    //   setExceedVideoConstraintsIfNecessary — falls back to picking the lowest
+    //     HEVC rendition rather than failing if every HEVC track exceeds the
+    //     default 1080p/30fps viewport constraint on small surfaces.
+    val trackSelector = DefaultTrackSelector(context).apply {
+      setParameters(
+        buildUponParameters()
+          .setAllowVideoMixedMimeTypeAdaptiveness(true)
+          .setAllowVideoNonSeamlessAdaptiveness(true)
+          .setExceedVideoConstraintsIfNecessary(true)
+      )
+    }
+
+    player = ExoPlayer.Builder(context)
+      .setLoadControl(loadControl)
+      .setLooper(Looper.getMainLooper())
+      .setRenderersFactory(renderersFactory)
+      .setTrackSelector(trackSelector)
+      .build()
+
+    loadedWithSource = true
+
+    player.addListener(playerListener)
+    player.addAnalyticsListener(analyticsListener)
+    player.setMediaSource(hybridSource.mediaSource)
+
+    // Emit onLoadStart
+    val sourceType = if (hybridSource.uri.startsWith("http")) SourceType.NETWORK else SourceType.LOCAL
+    eventEmitter.onLoadStart(onLoadStartData(sourceType = sourceType, source = hybridSource))
+    status = VideoPlayerStatus.LOADING
+    startProgressUpdates()
+  }
+
+  override fun initialize(): Promise<Unit> {
+    return Promise.async {
+      return@async runOnMainThreadSync {
+        initializePlayer()
+        player.prepare()
+      }
+    }
+  }
+
+  constructor(source: HybridVideoPlayerSource) : this() {
+    this.source = source
+
+    runOnMainThread {
+      if (source.config.initializeOnCreation == true) {
+        initializePlayer()
+        player.prepare()
+      }
+    }
+
+    VideoManager.registerPlayer(this)
+  }
+
+  override fun play() {
+    runOnMainThread {
+      player.play()
+    }
+  }
+
+  override fun pause() {
+    runOnMainThread {
+      player.pause()
+    }
+  }
+
+  override fun seekBy(time: Double) {
+    currentTime = (currentTime + time).coerceIn(0.0, duration)
+  }
+
+  override fun seekTo(time: Double) {
+    currentTime = time.coerceIn(0.0, duration)
+  }
+
+  override fun replaceSourceAsync(source: Variant_NullType_HybridVideoPlayerSourceSpec?): Promise<Unit> {
+    return Promise.async {
+      val source = source?.asSecondOrNull()
+
+      if (source == null) {
+        release()
+        return@async
+      }
+
+      val hybridSource = source as? HybridVideoPlayerSource ?: throw PlayerError.InvalidSource
+
+      val oldSource = this.source as? HybridVideoPlayerSource
+      oldSource?.sourceLoader?.cancel()
+
+      runOnMainThreadSync {
+        // Update source
+        this.source = source
+        player.setMediaSource(hybridSource.mediaSource)
+
+        // Prepare player
+        player.prepare()
+      }
+    }
+  }
+
+  override fun preload(): Promise<Unit> {
+    return Promise.async {
+      runOnMainThreadSync {
+        if (!loadedWithSource) {
+          initializePlayer()
+        }
+
+        if (player.playbackState != Player.STATE_IDLE) {
+          return@runOnMainThreadSync
+        }
+
+        player.prepare()
+      }
+    }
+  }
+
+  override fun release() {
+    if (playInBackground || showNotificationControls) {
+      VideoPlaybackService.stopService(this, videoPlaybackServiceConnection)
+    }
+
+    runOnMainThread {
+      VideoManager.unregisterPlayer(this)
+      stopProgressUpdates()
+      loadedWithSource = false
+
+      eventEmitter.clearAllListeners()
+
+      player.removeListener(playerListener)
+      player.removeAnalyticsListener(analyticsListener)
+      player.release() // Release player
+
+      // Clean Listeners
+      audioFocusChangedListener.removeEventEmitter()
+      audioBecomingNoisyReceiver.removeEventEmitter()
+
+      // Update status
+      status = VideoPlayerStatus.IDLE
+    }
+  }
+
+  fun movePlayerToVideoView(videoView: VideoView) {
+    VideoManager.addViewToPlayer(videoView, this)
+
+    runOnMainThreadSync {
+      PlayerView.switchTargetView(player, currentPlayerView?.get(), videoView.playerView)
+      currentPlayerView = WeakReference(videoView.playerView)
+    }
+  }
+
+  override fun dispose() {
+    release()
+  }
+
+  override fun close() {
+    release()
+  }
+
+  override val memorySize: Long
+    // 1 MiB by default
+    get() = allocator?.totalBytesAllocated?.toLong() ?: (1024L * 1024L)
+
+  private fun startProgressUpdates() {
+    stopProgressUpdates() // Ensure no multiple runnables
+    progressRunnable = object : Runnable {
+      override fun run() {
+        if (player.playbackState != Player.STATE_IDLE && player.playbackState != Player.STATE_ENDED) {
+          val currentTimeSeconds = player.currentPosition / 1000.0
+          val bufferedDurationSeconds = player.bufferedPosition / 1000.0
+          // bufferDuration is the time from current time that is buffered.
+          val playableDurationFromNow = max(0.0, bufferedDurationSeconds - currentTimeSeconds)
+
+          val durationSeconds = if (player.duration == C.TIME_UNSET) Double.NaN else player.duration / 1000.0
+
+          eventEmitter.onProgress(
+            onProgressData(
+              currentTime = currentTimeSeconds,
+              duration = durationSeconds,
+              bufferDuration = playableDurationFromNow
+            )
+          )
+          progressHandler.postDelayed(this, PROGRESS_UPDATE_INTERVAL_MS)
+        }
+      }
+    }
+    progressHandler.post(progressRunnable ?: return)
+  }
+
+  private fun stopProgressUpdates() {
+    progressRunnable?.let { progressHandler.removeCallbacks(it) }
+    progressRunnable = null
+  }
+
+  private val analyticsListener = object: AnalyticsListener {
+    override fun onBandwidthEstimate(
+      eventTime: AnalyticsListener.EventTime,
+      totalLoadTimeMs: Int,
+      totalBytesLoaded: Long,
+      bitrateEstimate: Long
+    ) {
+      val videoFormat = player.videoFormat
+      eventEmitter.onBandwidthUpdate(
+        BandwidthData(
+          bitrate = bitrateEstimate.toDouble(),
+          width = if (videoFormat != null) videoFormat.width.toDouble() else null,
+          height = if (videoFormat != null) videoFormat.height.toDouble() else null
+        )
+      )
+    }
+  }
+
+  private val playerListener = object : Player.Listener {
+    override fun onPlaybackStateChanged(playbackState: Int) {
+      val isPlayingUpdate = player.isPlaying
+      val isBufferingUpdate = playbackState == Player.STATE_BUFFERING
+
+      eventEmitter.onPlaybackStateChange(
+        onPlaybackStateChangeData(
+          isPlaying = isPlayingUpdate,
+          isBuffering = isBufferingUpdate
+        )
+      )
+
+      when (playbackState) {
+        Player.STATE_IDLE -> {
+          status = VideoPlayerStatus.IDLE
+          eventEmitter.onBuffer(false)
+        }
+        Player.STATE_BUFFERING -> {
+          status = VideoPlayerStatus.LOADING
+          eventEmitter.onBuffer(true)
+        }
+        Player.STATE_READY -> {
+          status = VideoPlayerStatus.READYTOPLAY
+          eventEmitter.onBuffer(false)
+
+          val generalVideoFormat = player.videoFormat
+          val currentTracks = player.currentTracks
+
+          val selectedVideoTrackGroup = currentTracks.groups.find { group -> group.type == C.TRACK_TYPE_VIDEO && group.isSelected }
+          val selectedVideoTrackFormat = if (selectedVideoTrackGroup != null && selectedVideoTrackGroup.length > 0) {
+            selectedVideoTrackGroup.getTrackFormat(0)
+          } else {
+            null
+          }
+
+          val width = selectedVideoTrackFormat?.width ?: generalVideoFormat?.width ?: 0
+          val height = selectedVideoTrackFormat?.height ?: generalVideoFormat?.height ?: 0
+          val rotationDegrees = selectedVideoTrackFormat?.rotationDegrees ?: generalVideoFormat?.rotationDegrees
+
+          eventEmitter.onLoad(
+            onLoadData(
+              currentTime = player.currentPosition / 1000.0,
+              duration = if (player.duration == C.TIME_UNSET) Double.NaN else player.duration / 1000.0,
+              width = width.toDouble(),
+              height = height.toDouble(),
+              orientation = VideoOrientationUtils.fromWHR(width, height, rotationDegrees)
+            )
+          )
+          // If player becomes ready and is set to play, start progress updates
+          if (player.playWhenReady) {
+            startProgressUpdates()
+          }
+
+          eventEmitter.onReadyToDisplay()
+        }
+        Player.STATE_ENDED -> {
+          status = VideoPlayerStatus.IDLE // Or a specific 'COMPLETED' status if you add one
+          eventEmitter.onEnd()
+          eventEmitter.onBuffer(false)
+          stopProgressUpdates()
+        }
+      }
+    }
+
+    override fun onIsPlayingChanged(isPlaying: Boolean) {
+      super.onIsPlayingChanged(isPlaying)
+      eventEmitter.onPlaybackStateChange(
+        onPlaybackStateChangeData(
+          isPlaying = isPlaying,
+          isBuffering = player.playbackState == Player.STATE_BUFFERING
+        )
+      )
+      if (isPlaying) {
+        VideoManager.setLastPlayedPlayer(this@HybridVideoPlayer)
+        startProgressUpdates()
+      } else {
+        if (player.playbackState == Player.STATE_ENDED || player.playbackState == Player.STATE_IDLE) {
+          stopProgressUpdates()
+        }
+      }
+    }
+
+    override fun onPlayerError(error: PlaybackException) {
+      Log.e(TAG, "Player error: ${error.errorCodeName} - ${error.message}", error)
+      status = VideoPlayerStatus.ERROR
+      stopProgressUpdates()
+    }
+
+    override fun onPositionDiscontinuity(
+      oldPosition: Player.PositionInfo,
+      newPosition: Player.PositionInfo,
+      reason: Int
+    ) {
+      if (reason == Player.DISCONTINUITY_REASON_SEEK || reason == Player.DISCONTINUITY_REASON_SEEK_ADJUSTMENT) {
+        eventEmitter.onSeek(newPosition.positionMs / 1000.0)
+      }
+      // Update progress immediately after a discontinuity if needed by your logic
+       val currentTimeSeconds = newPosition.positionMs / 1000.0
+       val bufferedDurationSeconds = player.bufferedPosition / 1000.0
+       val durationSeconds = if (player.duration == C.TIME_UNSET) Double.NaN else player.duration / 1000.0
+       eventEmitter.onProgress(
+         onProgressData(
+           currentTime = currentTimeSeconds,
+           duration = durationSeconds,
+           bufferDuration = max(0.0, bufferedDurationSeconds - currentTimeSeconds)
+         )
+       )
+    }
+
+    override fun onPlaybackParametersChanged(playbackParameters: PlaybackParameters) {
+      eventEmitter.onPlaybackRateChange(playbackParameters.speed.toDouble())
+    }
+
+    override fun onVolumeChanged(volume: Float) {
+      // We get here device volume changes, and if
+      // player is not muted we will sync it
+      if (!muted) {
+        this@HybridVideoPlayer.volume = volume.toDouble()
+      }
+
+      VideoManager.audioFocusManager.requestAudioFocusUpdate()
+      eventEmitter.onVolumeChange(onVolumeChangeData(
+        volume = volume.toDouble(),
+        muted = muted
+      ))
+    }
+
+    override fun onCues(cueGroup: CueGroup) {
+      val texts = cueGroup.cues.mapNotNull { it.text?.toString() }
+      if (texts.isNotEmpty()) {
+        eventEmitter.onTextTrackDataChanged(texts.toTypedArray())
+      }
+    }
+
+    override fun onMetadata(metadata: Metadata) {
+      val timedMetadataObjects = mutableListOf<TimedMetadataObject>()
+      for (i in 0 until metadata.length()) {
+        val entry = metadata.get(i)
+
+        when (entry) {
+          is Id3Frame -> {
+            var value = ""
+
+            if (entry is TextInformationFrame) {
+              value = entry.values.first()
+            }
+
+            timedMetadataObjects.add(TimedMetadataObject(entry.id, value))
+          }
+          is EventMessage ->
+            timedMetadataObjects.add(TimedMetadataObject(entry.schemeIdUri, entry.value))
+          else -> Log.d(TAG, "Unknown metadata: $entry")
+        }
+      }
+      if (timedMetadataObjects.isNotEmpty()) {
+        eventEmitter.onTimedMetadata(TimedMetadata(metadata = timedMetadataObjects.toTypedArray()))
+      }
+    }
+
+    override fun onTracksChanged(tracks: Tracks) {
+      super.onTracksChanged(tracks)
+    }
+  }
+
+  // MARK: - Frame Capture
+
+  override fun captureFrame(): Promise<String> {
+    return Promise.async {
+      val hybridSource = source as? HybridVideoPlayerSource
+        ?: throw PlayerError.InvalidSource
+
+      // Try to capture from TextureView first (if using texture surface type)
+      val textureViewBitmap = runOnMainThreadSync {
+        try {
+          val playerView = currentPlayerView?.get()
+          if (playerView != null) {
+            // Find TextureView in the player view hierarchy
+            for (i in 0 until playerView.childCount) {
+              val child = playerView.getChildAt(i)
+              if (child is TextureView && child.isAvailable) {
+                return@runOnMainThreadSync child.bitmap
+              }
+            }
+          }
+          null
+        } catch (e: Exception) {
+          Log.w(TAG, "Failed to capture from TextureView", e)
+          null
+        }
+      }
+
+      if (textureViewBitmap != null) {
+        return@async bitmapToBase64(textureViewBitmap)
+      }
+
+      // Fallback: Use MediaMetadataRetriever for frame extraction
+      val retriever = MediaMetadataRetriever()
+      try {
+        val uri = hybridSource.uri
+        if (uri.startsWith("http://") || uri.startsWith("https://")) {
+          retriever.setDataSource(uri, HashMap())
+        } else {
+          retriever.setDataSource(context, android.net.Uri.parse(uri))
+        }
+
+        // Get frame at current position (in microseconds)
+        val currentPositionUs = (currentTime * 1_000_000).toLong()
+        val bitmap = retriever.getFrameAtTime(
+          currentPositionUs,
+          MediaMetadataRetriever.OPTION_CLOSEST_SYNC
+        ) ?: throw PlayerError.NotInitialized
+
+        return@async bitmapToBase64(bitmap)
+      } catch (e: Exception) {
+        Log.e(TAG, "Failed to capture frame", e)
+        throw PlayerError.NotInitialized
+      } finally {
+        try {
+          retriever.release()
+        } catch (e: Exception) {
+          Log.w(TAG, "Failed to release MediaMetadataRetriever", e)
+        }
+      }
+    }
+  }
+
+  private fun bitmapToBase64(bitmap: Bitmap): String {
+    val outputStream = ByteArrayOutputStream()
+    bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
+    val byteArray = outputStream.toByteArray()
+    return Base64.encodeToString(byteArray, Base64.NO_WRAP)
+  }
+
+  // MARK: - Text Track Management
+
+  override fun getAvailableTextTracks(): Array<TextTrack> {
+    return TextTrackUtils.getAvailableTextTracks(player, source)
+  }
+
+  override fun selectTextTrack(textTrack: Variant_NullType_TextTrack?) {
+    selectedExternalTrackIndex = TextTrackUtils.selectTextTrack(
+      player = player,
+      textTrack = textTrack?.asSecondOrNull(),
+      source = source,
+      onTrackChange = { track -> eventEmitter.onTrackChange(track) }
+    )
+  }
+
+  override val selectedTrack: TextTrack?
+    get() = TextTrackUtils.getSelectedTrack(player, source)
+}