spactureai-mobile-player 1.0.30

package/android/src/main/java/com/unifiedplayer/core/fragments/FullscreenVideoFragment.kt

@@ -0,0 +1,346 @@
+package com.unifiedplayer.core.fragments
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.pm.ActivityInfo
+import android.content.res.Configuration
+import android.os.Build
+import android.os.Bundle
+import android.view.Gravity
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowInsets
+import android.view.WindowInsetsController
+import android.view.WindowManager
+import android.widget.FrameLayout
+import android.widget.ImageButton
+import android.widget.TextView
+import androidx.activity.OnBackPressedCallback
+import androidx.annotation.OptIn
+import androidx.core.view.isVisible
+import androidx.fragment.app.Fragment
+import androidx.media3.common.util.UnstableApi
+import com.unifiedplayer.core.utils.PictureInPictureUtils.createPictureInPictureParams
+import com.unifiedplayer.core.utils.SmallVideoPlayerOptimizer
+import com.unifiedplayer.view.VideoView
+import java.util.UUID
+
+@OptIn(UnstableApi::class)
+class FullscreenVideoFragment(private val videoView: VideoView) : Fragment() {
+  val id: String = UUID.randomUUID().toString()
+
+  private var container: FrameLayout? = null
+  private var originalPlayerParent: ViewGroup? = null
+  private var originalPlayerLayoutParams: ViewGroup.LayoutParams? = null
+  private var rootContentViews: List<View> = listOf()
+  private var originalOrientation: Int? = null
+
+  // Back press callback to handle back navigation
+  private val backPressCallback = object : OnBackPressedCallback(true) {
+    override fun handleOnBackPressed() {
+      videoView.exitFullscreen()
+    }
+  }
+
+  override fun onCreateView(
+    inflater: LayoutInflater,
+    container: ViewGroup?,
+    savedInstanceState: Bundle?
+  ): View? {
+    // Create a fullscreen container
+    this.container = FrameLayout(requireContext()).apply {
+      layoutParams = ViewGroup.LayoutParams(
+        ViewGroup.LayoutParams.MATCH_PARENT,
+        ViewGroup.LayoutParams.MATCH_PARENT
+      )
+      setBackgroundColor(android.graphics.Color.BLACK)
+      keepScreenOn = true
+    }
+    return this.container
+  }
+
+  override fun onSaveInstanceState(outState: Bundle) {
+    super.onSaveInstanceState(outState)
+    originalOrientation?.let { outState.putInt("originalOrientation", it) }
+  }
+
+  override fun onResume() {
+    super.onResume()
+
+    // System UI is re-enabled when user have exited app and go back
+    // We need to hide it again
+    hideSystemUI()
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+
+    // Register back press callback
+    requireActivity().onBackPressedDispatcher.addCallback(viewLifecycleOwner, backPressCallback)
+
+    enterFullscreenMode()
+    setupPlayerView()
+    hideSystemUI()
+
+    // Update PiP params if supported
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      try {
+        val params = createPictureInPictureParams(videoView)
+        requireActivity().setPictureInPictureParams(params)
+      } catch (_: Exception) {}
+    }
+
+
+
+    // Creating a fullscreen fragment usually means we want to be in landscape
+    if (savedInstanceState != null && savedInstanceState.containsKey("originalOrientation")) {
+      originalOrientation = savedInstanceState.getInt("originalOrientation")
+    } else {
+      originalOrientation = requireActivity().requestedOrientation
+    }
+    requireActivity().requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+  }
+
+  override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
+    super.onPictureInPictureModeChanged(isInPictureInPictureMode)
+
+    if (isInPictureInPictureMode) {
+      videoView.playerView.useController = false
+      videoView.playerView.controllerAutoShow = false
+    } else {
+      // In fullscreen, we always want controls enabled
+      videoView.playerView.useController = true
+      videoView.playerView.controllerAutoShow = true
+    }
+  }
+
+  override fun onConfigurationChanged(newConfig: Configuration) {
+    super.onConfigurationChanged(newConfig)
+
+    val isInPictureInPictureMode = requireActivity().isInPictureInPictureMode
+
+    if (isInPictureInPictureMode) {
+      videoView.playerView.useController = false
+      videoView.playerView.controllerAutoShow = false
+    } else {
+      // In fullscreen, we always want controls enabled
+      videoView.playerView.useController = true
+      videoView.playerView.controllerAutoShow = true
+    }
+  }
+
+  private fun enterFullscreenMode() {
+    // Store original parent and layout params
+    originalPlayerParent = videoView.playerView.parent as? ViewGroup
+    originalPlayerLayoutParams = videoView.playerView.layoutParams
+
+    // Remove player from original parent
+    originalPlayerParent?.removeView(videoView.playerView)
+
+    // Hide all root content views
+    val currentActivity = requireActivity()
+    val rootContent = currentActivity.window.decorView.findViewById<ViewGroup>(android.R.id.content)
+    rootContentViews = (0 until rootContent.childCount)
+      .map { rootContent.getChildAt(it) }
+      .filter { it.isVisible }
+
+    rootContentViews.forEach { view ->
+      view.visibility = View.GONE
+    }
+
+    // Add our fullscreen container to root
+    rootContent.addView(container,
+      ViewGroup.LayoutParams(
+        ViewGroup.LayoutParams.MATCH_PARENT,
+        ViewGroup.LayoutParams.MATCH_PARENT
+      )
+    )
+  }
+
+  private fun setupPlayerView() {
+    // Add PlayerView to our container
+    container?.addView(videoView.playerView,
+      FrameLayout.LayoutParams(
+        FrameLayout.LayoutParams.MATCH_PARENT,
+        FrameLayout.LayoutParams.MATCH_PARENT
+      )
+    )
+
+    videoView.playerView.setBackgroundColor(android.graphics.Color.BLACK)
+    videoView.playerView.setShutterBackgroundColor(android.graphics.Color.BLACK)
+
+    // We need show controls in fullscreen
+    videoView.playerView.useController = true
+
+    setupFullscreenButton()
+    videoView.playerView.setShowSubtitleButton(true)
+    
+    // Apply optimizations based on video player size in fullscreen mode
+    SmallVideoPlayerOptimizer.applyOptimizations(videoView.playerView, requireContext(), isFullscreen = true)
+
+    // Add close button after player view so it's on top
+    setupCloseButton()
+
+    // Add playback speed button logic
+    setupPlaybackSpeedButton()
+
+    // Show controller initially
+    videoView.playerView.showController()
+  }
+
+  private fun setupPlaybackSpeedButton() {
+    val speedButton = videoView.playerView.findViewById<TextView>(com.unifiedplayer.R.id.exo_playback_speed)
+    
+    speedButton?.setOnClickListener {
+      val player = videoView.playerView.player ?: return@setOnClickListener
+      val currentSpeed = player.playbackParameters.speed
+      
+      val nextSpeed = when (currentSpeed) {
+        1.0f -> 2.0f
+        2.0f -> 4.0f
+        4.0f -> 1.0f
+        else -> 1.0f
+      }
+      
+      player.setPlaybackSpeed(nextSpeed)
+      speedButton.text = "${nextSpeed}x"
+    }
+  }
+
+  private fun setupCloseButton() {
+    val context = requireContext()
+    val closeButton = ImageButton(context).apply {
+      setImageResource(android.R.drawable.ic_menu_close_clear_cancel)
+      setBackgroundColor(android.graphics.Color.TRANSPARENT)
+      setColorFilter(android.graphics.Color.WHITE)
+      setPadding(16, 16, 16, 16)
+      
+      layoutParams = FrameLayout.LayoutParams(
+        ViewGroup.LayoutParams.WRAP_CONTENT,
+        ViewGroup.LayoutParams.WRAP_CONTENT
+      ).apply {
+        gravity = Gravity.TOP or Gravity.START
+        topMargin = 64
+        leftMargin = 64
+      }
+      
+      setOnClickListener {
+        exitFullscreen()
+      }
+    }
+    
+    container?.addView(closeButton)
+  }
+
+  @SuppressLint("PrivateResource")
+  private fun setupFullscreenButton() {
+    videoView.playerView.setFullscreenButtonClickListener { _ ->
+      videoView.exitFullscreen()
+    }
+
+    // Change icon to exit fullscreen
+    val button = videoView.playerView.findViewById<ImageButton>(androidx.media3.ui.R.id.exo_fullscreen)
+    button?.setImageResource(androidx.media3.ui.R.drawable.exo_icon_fullscreen_exit)
+  }
+
+  @Suppress("DEPRECATION")
+  private fun hideSystemUI() {
+    val currentActivity = requireActivity()
+    container?.let { container ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        container.fitsSystemWindows = false
+        container.windowInsetsController?.let { controller ->
+          controller.hide(WindowInsets.Type.systemBars())
+          controller.systemBarsBehavior = WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        }
+      } else {
+        currentActivity.window.decorView.systemUiVisibility = (
+          View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+          or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+          or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+          or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+          or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+          or View.SYSTEM_UI_FLAG_FULLSCREEN
+        )
+      }
+    }
+  }
+
+  @Suppress("DEPRECATION")
+  private fun restoreSystemUI() {
+    val currentActivity = requireActivity()
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      container?.windowInsetsController?.show(WindowInsets.Type.systemBars())
+    } else {
+      currentActivity.window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_VISIBLE
+    }
+  }
+
+  fun exitFullscreen() {
+    // Remove back press callback since we're exiting
+    backPressCallback.remove()
+
+    restoreSystemUI()
+
+    // Restore original orientation
+    originalOrientation?.let { orientation ->
+      requireActivity().requestedOrientation = orientation
+    }
+    originalOrientation = null
+
+    // Restore controller state from VideoView settings
+    videoView.playerView.useController = videoView.useController
+    if (videoView.useController) {
+      videoView.playerView.controllerAutoShow = true
+    } else {
+      videoView.playerView.hideController()
+      videoView.playerView.controllerAutoShow = false
+    }
+
+    // Ensure PlayerView keeps black background when returning to normal mode
+    videoView.playerView.setBackgroundColor(android.graphics.Color.BLACK)
+    videoView.playerView.setShutterBackgroundColor(android.graphics.Color.BLACK)
+
+  // Remove PlayerView from our container
+  container?.removeView(videoView.playerView)
+
+    // Remove our container from root
+    val currentActivity = requireActivity()
+    val rootContent = currentActivity.window.decorView.findViewById<ViewGroup>(android.R.id.content)
+    rootContent.removeView(container)
+
+    // Restore root content views
+    rootContentViews.forEach { it.visibility = View.VISIBLE }
+    rootContentViews = listOf()
+
+    // Safely restore PlayerView to original parent
+    // First, ensure PlayerView is removed from any current parent
+    val currentParent = videoView.playerView.parent as? ViewGroup
+    currentParent?.removeView(videoView.playerView)
+
+    // Now add it back to the original parent if it's not already the parent
+    if (videoView.playerView.parent != originalPlayerParent) {
+      originalPlayerParent?.addView(videoView.playerView, originalPlayerLayoutParams)
+    }
+
+    // Remove this fragment
+    parentFragmentManager.beginTransaction()
+      .remove(this)
+      .commitAllowingStateLoss()
+
+    // Notify VideoView that we've exited fullscreen
+    videoView.isInFullscreen = false
+  }
+
+
+
+  override fun onDestroy() {
+    super.onDestroy()
+
+    // Ensure we clean up properly if fragment is destroyed
+    if (videoView.isInFullscreen) {
+      exitFullscreen()
+    }
+  }
+}

package/android/src/main/java/com/unifiedplayer/core/fragments/PictureInPictureHelperFragment.kt

@@ -0,0 +1,85 @@
+package com.unifiedplayer.core.fragments
+
+import android.content.res.Configuration
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.fragment.app.Fragment
+import androidx.media3.common.util.UnstableApi
+import com.unifiedplayer.core.VideoManager
+import com.unifiedplayer.view.VideoView
+import java.util.UUID
+
+@OptIn(UnstableApi::class)
+class PictureInPictureHelperFragment(private val videoView: VideoView) : Fragment() {
+  val id: String = UUID.randomUUID().toString()
+
+  override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
+    super.onPictureInPictureModeChanged(isInPictureInPictureMode)
+
+    if (isInPictureInPictureMode) {
+      var currentPipVideo = VideoManager.getCurrentPictureInPictureVideo()
+      
+      if (currentPipVideo == null) {
+        synchronized(VideoManager) {
+          currentPipVideo = VideoManager.getCurrentPictureInPictureVideo()
+          if (currentPipVideo == null) {
+            if (videoView.hybridPlayer?.isPlaying == true) {
+              val lastPlayed = VideoManager.getLastPlayedVideoView()
+              val shouldDesignate = lastPlayed == null || lastPlayed.nitroId == videoView.nitroId
+
+              if (shouldDesignate) {
+                VideoManager.setCurrentPictureInPictureVideo(videoView)
+                videoView.hybridPlayer?.movePlayerToVideoView(videoView)
+                VideoManager.pauseOtherPlayers(videoView)
+                currentPipVideo = videoView
+              }
+            } else {
+              if (!VideoManager.isAnyVideoInPictureInPicture()) {
+                val lastPlayed = VideoManager.getLastPlayedVideoView()
+                val targetView = lastPlayed ?: videoView
+
+                VideoManager.setCurrentPictureInPictureVideo(targetView)
+                targetView.hybridPlayer?.movePlayerToVideoView(targetView)
+                VideoManager.pauseOtherPlayers(targetView)
+                currentPipVideo = targetView
+              }
+            }
+          }
+        }
+      }
+      
+      if (currentPipVideo == videoView) {
+        // Disable controls immediately when entering PiP - media session creates its own controls for PiP
+        videoView.playerView.useController = false
+        videoView.playerView.controllerAutoShow = false
+
+        // If we're currently in fullscreen, exit it first to prevent parent conflicts
+        if (videoView.isInFullscreen) {
+          try {
+            videoView.exitFullscreen()
+            // Post hideRootContentViews to main thread to ensure it runs after exitFullscreen completes
+            Handler(Looper.getMainLooper()).post {
+              videoView.hideRootContentViews()
+              videoView.isInPictureInPicture = true
+            }
+          } catch (e: Exception) {
+            Log.w("UnifiedPlayer", "Failed to exit fullscreen before entering PiP for nitroId: ${videoView.nitroId}", e)
+            videoView.hideRootContentViews()
+            videoView.isInPictureInPicture = true
+          }
+        } else {
+          // Now move the PlayerView to the root for PiP and hide content
+          videoView.hideRootContentViews()
+          videoView.isInPictureInPicture = true
+        }
+      }
+    } else {
+      if (videoView.isInPictureInPicture) {
+        videoView.exitPictureInPicture()
+      }
+    }
+  }
+}

package/android/src/main/java/com/unifiedplayer/core/player/DRMManagerSpec.kt

@@ -0,0 +1,23 @@
+package com.unifiedplayer.core.player
+
+import androidx.annotation.OptIn
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.common.util.Util
+import androidx.media3.exoplayer.drm.DrmSessionManager
+import com.margelo.nitro.unifiedplayer.NativeDrmParams
+import java.util.UUID
+
+@OptIn(UnstableApi::class)
+interface DRMManagerSpec {
+  fun buildDrmSessionManager(drmParams: NativeDrmParams): DrmSessionManager {
+    val drmScheme = drmParams.type ?: "widevine"
+    val drmUuid = Util.getDrmUuid(drmScheme)
+
+    return buildDrmSessionManager(drmParams, drmUuid)
+  }
+
+  fun buildDrmSessionManager(drmParams: NativeDrmParams, drmUuid: UUID?, retryCount: Int = 0): DrmSessionManager
+
+  fun getDRMConfiguration(drmParams: NativeDrmParams): MediaItem.DrmConfiguration
+}

package/android/src/main/java/com/unifiedplayer/core/player/DataSourceFactoryUtils.kt

@@ -0,0 +1,93 @@
+package com.unifiedplayer.core.player
+
+import android.content.Context
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.common.util.Util
+import androidx.media3.datasource.DefaultDataSource
+import androidx.media3.datasource.okhttp.OkHttpDataSource
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.network.CookieJarContainer
+import com.facebook.react.modules.network.ForwardingCookieHandler
+import com.facebook.react.modules.network.OkHttpClientProvider
+import com.margelo.nitro.unifiedplayer.HybridVideoPlayerSourceSpec
+import okhttp3.Dispatcher
+import okhttp3.JavaNetCookieJar
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+fun buildBaseDataSourceFactory(context: Context, source: HybridVideoPlayerSourceSpec): DefaultDataSource.Factory {
+  return if (source.uri.startsWith("http")) {
+    DefaultDataSource.Factory(context, buildHttpDataSourceFactory(context, source))
+  } else {
+    DefaultDataSource.Factory(context)
+  }
+}
+
+/**
+ * Dedicated OkHttp client used by the HLS / DASH / progressive data
+ * source. Built once on first access and shared across player instances.
+ *
+ * Why a dedicated client (instead of reusing
+ * `OkHttpClientProvider.getOkHttpClient()` directly):
+ *   • RN's shared client uses OkHttp's default `Dispatcher`
+ *     (`maxRequestsPerHost = 5`). HLS playback wants to parallel-fetch
+ *     several segments after a seek — with the shared client those
+ *     requests queue behind whatever API traffic the rest of the app is
+ *     making, producing visible buffer stalls.
+ *   • Disabling the response cache prevents double-buffering: ExoPlayer
+ *     already maintains its own segment buffer; an OkHttp cache on top
+ *     just adds memory pressure.
+ *   • Mirrors the iOS-side fix in `AuthHeaderAssetResourceLoader.swift`
+ *     (`httpMaximumConnectionsPerHost = 10`, `urlCache = nil`,
+ *     `requestCachePolicy = reloadIgnoringLocalCacheData`) so behaviour
+ *     stays consistent across platforms.
+ */
+private val playbackHttpClient: OkHttpClient by lazy {
+  val sharedClient = OkHttpClientProvider.getOkHttpClient()
+
+  val playbackDispatcher = Dispatcher().apply {
+    maxRequests = 64
+    maxRequestsPerHost = 10
+  }
+
+  sharedClient.newBuilder()
+    .dispatcher(playbackDispatcher)
+    .cache(null)
+    .connectTimeout(30, TimeUnit.SECONDS)
+    .readTimeout(30, TimeUnit.SECONDS)
+    .writeTimeout(30, TimeUnit.SECONDS)
+    .build()
+}
+
+@OptIn(UnstableApi::class)
+fun buildHttpDataSourceFactory(context: Context, source: HybridVideoPlayerSourceSpec): OkHttpDataSource.Factory {
+  // Forward RN's cookie handler onto the SHARED client's CookieJar so
+  // any cookie-based session auth (e.g. set during regular API calls)
+  // is visible to playback requests. The dedicated `playbackHttpClient`
+  // inherits the same CookieJar via `newBuilder()`.
+  if (context is ReactContext) {
+    val sharedClient = OkHttpClientProvider.getOkHttpClient()
+    val handler = ForwardingCookieHandler(context)
+    (sharedClient.cookieJar as CookieJarContainer).setCookieJar(JavaNetCookieJar(handler))
+  }
+
+  val factory = OkHttpDataSource.Factory(playbackHttpClient)
+
+  val headers: Map<String, String>? = source.config.headers
+
+  if (headers != null) {
+    factory.setDefaultRequestProperties(headers)
+  }
+
+  if (headers == null || !headers.containsKey("User-Agent")) {
+    factory.setUserAgent(getUserAgent(context))
+  }
+
+  return factory
+}
+
+@OptIn(UnstableApi::class)
+fun getUserAgent(context: Context): String {
+  return Util.getUserAgent(context, context.packageName)
+}

package/android/src/main/java/com/unifiedplayer/core/player/MediaItemUtils.kt

@@ -0,0 +1,141 @@
+package com.unifiedplayer.core.player
+
+import android.util.Log
+import android.webkit.MimeTypeMap
+import androidx.annotation.OptIn
+import androidx.core.net.toUri
+import androidx.media3.common.MediaItem
+import androidx.media3.common.C
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.util.UnstableApi
+import com.margelo.nitro.unifiedplayer.BufferConfig
+import com.margelo.nitro.unifiedplayer.CustomVideoMetadata
+import com.margelo.nitro.unifiedplayer.HybridVideoPlayerSource
+import com.margelo.nitro.unifiedplayer.LivePlaybackParams
+import com.margelo.nitro.unifiedplayer.NativeDrmParams
+import com.margelo.nitro.unifiedplayer.NativeVideoConfig
+import com.margelo.nitro.unifiedplayer.SubtitleType
+import com.unifiedplayer.core.LibraryError
+import com.unifiedplayer.core.SourceError
+import com.unifiedplayer.core.extensions.toStringExtension
+import com.unifiedplayer.core.plugins.PluginsRegistry
+
+private const val TAG = "MediaItemUtils"
+
+@OptIn(UnstableApi::class)
+fun createMediaItemFromVideoConfig(
+  source: HybridVideoPlayerSource
+): MediaItem {
+  val mediaItemBuilder = MediaItem.Builder()
+
+  mediaItemBuilder.setUri(source.config.uri)
+
+  source.config.drm?.let { drmParams ->
+    val drmManager = source.drmManager ?: throw LibraryError.DRMPluginNotFound
+    val drmConfiguration = drmManager.getDRMConfiguration(drmParams)
+    mediaItemBuilder.setDrmConfiguration(drmConfiguration)
+  }
+
+  source.config.bufferConfig?.livePlayback?.let { livePlaybackParams ->
+    mediaItemBuilder.setLiveConfiguration(getLiveConfiguration(livePlaybackParams))
+  }
+
+  source.config.metadata?.let { metadata ->
+    mediaItemBuilder.setMediaMetadata(getCustomMetadata(metadata))
+  }
+
+  return PluginsRegistry.shared.overrideMediaItemBuilder(
+    source,
+    mediaItemBuilder
+  ).build()
+}
+
+fun getSubtitlesConfiguration(
+  config: NativeVideoConfig,
+): List<MediaItem.SubtitleConfiguration> {
+  val subtitlesConfiguration: MutableList<MediaItem.SubtitleConfiguration> = mutableListOf()
+
+  if (config.externalSubtitles != null) {
+    for (subtitle in config.externalSubtitles) {
+      val ext = if (subtitle.type == SubtitleType.AUTO) {
+        MimeTypeMap.getFileExtensionFromUrl(subtitle.uri)
+      } else {
+        subtitle.type.toStringExtension()
+      }
+
+      val mimeType = when (ext?.lowercase()) {
+        "srt" -> MimeTypes.APPLICATION_SUBRIP
+        "vtt" -> MimeTypes.TEXT_VTT
+        "ssa", "ass" -> MimeTypes.TEXT_SSA
+        else -> {
+          Log.e(TAG, "Unsupported subtitle extension '$ext' for URI: ${subtitle.uri}. Skipping this subtitle.")
+          continue
+        }
+      }
+
+      try {
+        val subtitleConfig = MediaItem.SubtitleConfiguration.Builder(subtitle.uri.toUri())
+          .setId("external-subtitle-${subtitle.uri}")
+          .setMimeType(mimeType)
+          .setSelectionFlags(C.SELECTION_FLAG_DEFAULT)
+          .setRoleFlags(C.ROLE_FLAG_SUBTITLE)
+          .setLabel(subtitle.label)
+          .build()
+        subtitlesConfiguration.add(subtitleConfig)
+      } catch (e: Exception) {
+        Log.e(TAG, "Error creating SubtitleConfiguration for URI ${subtitle.uri}: ${e.message}", e)
+      }
+    }
+  }
+  return subtitlesConfiguration
+}
+
+fun getLiveConfiguration(
+  livePlaybackParams: LivePlaybackParams
+): MediaItem.LiveConfiguration {
+  val liveConfiguration = MediaItem.LiveConfiguration.Builder()
+
+  livePlaybackParams.maxOffsetMs?.let {
+    if (it >= 0) {
+      liveConfiguration.setMaxOffsetMs(it.toLong())
+    }
+  }
+
+  livePlaybackParams.minOffsetMs?.let {
+    if (it >= 0) {
+      liveConfiguration.setMinOffsetMs(it.toLong())
+    }
+  }
+
+  livePlaybackParams.targetOffsetMs?.let {
+    if (it >= 0) {
+      liveConfiguration.setTargetOffsetMs(it.toLong())
+    }
+  }
+
+  livePlaybackParams.maxPlaybackSpeed?.let {
+    if (it >= 0) {
+      liveConfiguration.setMaxPlaybackSpeed(it.toFloat())
+    }
+  }
+
+  livePlaybackParams.minPlaybackSpeed?.let {
+    if (it >= 0) {
+      liveConfiguration.setMinPlaybackSpeed(it.toFloat())
+    }
+  }
+
+  return liveConfiguration.build()
+}
+
+fun getCustomMetadata(metadata: CustomVideoMetadata): MediaMetadata {
+  return MediaMetadata.Builder()
+    .setDisplayTitle(metadata.title)
+    .setTitle(metadata.title)
+    .setSubtitle(metadata.subtitle)
+    .setDescription(metadata.description)
+    .setArtist(metadata.artist)
+    .setArtworkUri(metadata.imageUri?.toUri())
+    .build()
+}