@pigeonmal/react-native-video 7.0.0-beta.2

package/android/src/main/java/com/twg/video/core/custom/MyTextRenderer.java

@@ -0,0 +1,121 @@
+package com.twg.video.core.custom;
+
+import androidx.annotation.Nullable;
+import androidx.media3.common.text.Cue;
+import androidx.media3.common.text.CueGroup;
+import androidx.media3.exoplayer.text.NonFinalTextRenderer;
+import androidx.media3.exoplayer.text.SubtitleDecoderFactory;
+import androidx.media3.exoplayer.text.TextOutput;
+
+import android.os.Looper;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+public class MyTextRenderer extends NonFinalTextRenderer implements TextSynchronizer, TextFilter {
+  private long offsetPositionUs;
+  private List<Pattern> regexFilters;
+
+  public MyTextRenderer(TextOutput output, @Nullable Looper outputLooper) {
+    super(output, outputLooper);
+    this.offsetPositionUs = 0l;
+    this.regexFilters = new ArrayList<Pattern>();
+  }
+
+  public MyTextRenderer(TextOutput output, @Nullable Looper outputLooper, SubtitleDecoderFactory decoderFactory) {
+    super(output, outputLooper, decoderFactory);
+    this.offsetPositionUs = 0l;
+    this.regexFilters = new ArrayList<Pattern>();
+  }
+
+  // ---------------------------------------------------------------------------
+  // implement: TextSynchronizer
+  // ---------------------------------------------------------------------------
+
+  @Override
+  public long getTextOffset() {
+    return offsetPositionUs;
+  }
+
+  @Override
+  public void setTextOffset(long value) {
+    offsetPositionUs = value;
+  }
+
+  @Override
+  public void addTextOffset(long value) {
+    offsetPositionUs += value;
+  }
+
+  // ---------------------------------------------------------------------------
+  // implement: TextFilter
+  // ---------------------------------------------------------------------------
+
+  @Override
+  public void setTextFilters(String[] textFilters) {
+    regexFilters.clear();
+    addTextFilters(textFilters);
+  }
+
+  @Override
+  public void addTextFilters(String[] textFilters) {
+    if (textFilters == null) return;
+    if (textFilters.length == 0) return;
+
+    for (String textFilter : textFilters) {
+      try {
+        Pattern regexFilter = Pattern.compile(textFilter);
+        regexFilters.add(regexFilter);
+      }
+      catch(Exception e) {}
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // override: NonFinalTextRenderer
+  // ---------------------------------------------------------------------------
+
+  @Override
+  public void render(long positionUs, long elapsedRealtimeUs) {
+    positionUs        += offsetPositionUs;
+    elapsedRealtimeUs += offsetPositionUs;
+
+    super.render(positionUs, elapsedRealtimeUs);
+  }
+
+  @Override
+  protected void invokeUpdateOutputInternal(CueGroup oldCueGroup) {
+    CueGroup newCueGroup = oldCueGroup;
+
+    if (!regexFilters.isEmpty()) {
+      List<Cue> newCues = new ArrayList<Cue>();
+
+      for (Cue oldCue : oldCueGroup.cues) {
+        if (oldCue.text == null) {
+          newCues.add(oldCue);
+        }
+        else {
+          String newText = oldCue.text.toString().trim();
+
+          for (Pattern pattern : regexFilters) {
+            newText = pattern.matcher(newText).replaceAll("").trim();
+          }
+
+          if (!newText.isEmpty()) {
+            Cue newCue = oldCue.buildUpon().setText(newText).build();
+            newCues.add(newCue);
+          }
+        }
+      }
+
+      newCueGroup = new CueGroup(
+        newCues,
+        oldCueGroup.presentationTimeUs
+      );
+    }
+
+    super.invokeUpdateOutputInternal(newCueGroup);
+  }
+
+}

package/android/src/main/java/com/twg/video/core/custom/TextFilter.java

@@ -0,0 +1,6 @@
+package com.twg.video.core.custom;
+
+public interface TextFilter {
+  void setTextFilters(String[] textFilters);
+  void addTextFilters(String[] textFilters);
+}

package/android/src/main/java/com/twg/video/core/custom/TextSynchronizer.java

@@ -0,0 +1,7 @@
+package com.twg.video.core.custom;
+
+public interface TextSynchronizer {
+  long getTextOffset();
+  void setTextOffset(long value);
+  void addTextOffset(long value);
+}

package/android/src/main/java/com/twg/video/core/extensions/ResizeMode+AspectRatioFrameLayout.kt

@@ -0,0 +1,20 @@
+package com.twg.video.core.extensions
+
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.AspectRatioFrameLayout
+import com.margelo.nitro.video.ResizeMode
+
+@OptIn(UnstableApi::class)
+/**
+ * Converts a [ResizeMode] to a [AspectRatioFrameLayout] resize mode.
+ * @return The corresponding [AspectRatioFrameLayout] resize mode.
+ */
+fun ResizeMode.toAspectRatioFrameLayout(): Int {
+  return when (this) {
+    ResizeMode.CONTAIN -> AspectRatioFrameLayout.RESIZE_MODE_FIT
+    ResizeMode.COVER -> AspectRatioFrameLayout.RESIZE_MODE_ZOOM
+    ResizeMode.STRETCH -> AspectRatioFrameLayout.RESIZE_MODE_FILL
+    ResizeMode.NONE -> AspectRatioFrameLayout.RESIZE_MODE_FIT
+  }
+}

package/android/src/main/java/com/twg/video/core/extensions/SubtitleType+toString.kt

@@ -0,0 +1,14 @@
+package com.twg.video.core.extensions
+
+import com.margelo.nitro.video.SubtitleType
+
+fun SubtitleType.toStringExtension(): String {
+  return when {
+    this == SubtitleType.AUTO -> "auto"
+    this == SubtitleType.VTT -> "vtt"
+    this == SubtitleType.SRT -> "srt"
+    this == SubtitleType.SSA -> "ssa"
+    this == SubtitleType.ASS -> "ass"
+    else -> throw IllegalArgumentException("Unknown SubtitleType: $this")
+  }
+}

package/android/src/main/java/com/twg/video/core/extensions/VideoPlaybackService+ServiceManagment.kt

@@ -0,0 +1,59 @@
+package com.twg.video.core.extensions
+
+import android.content.Context
+import android.content.Context.BIND_AUTO_CREATE
+import android.content.Context.BIND_INCLUDE_CAPABILITIES
+import android.content.Intent
+import android.os.Build
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.video.HybridVideoPlayer
+import com.twg.video.core.services.playback.VideoPlaybackService
+import com.twg.video.core.services.playback.VideoPlaybackServiceConnection
+
+fun VideoPlaybackService.Companion.startService(
+  context: Context,
+  serviceConnection: VideoPlaybackServiceConnection
+) {
+  val reactContext = NitroModules.applicationContext ?: return
+
+  val intent = Intent(context, VideoPlaybackService::class.java)
+  intent.action = VIDEO_PLAYBACK_SERVICE_INTERFACE
+
+  // Use startForegroundService on O+ so the service has the opportunity to call
+  // startForeground(...) quickly and avoid ForegroundServiceDidNotStartInTimeException.
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+    try {
+      reactContext.startForegroundService(intent)
+    } catch (_: Exception) {
+      // Fall back to startService if anything goes wrong
+      try { reactContext.startService(intent) } catch (_: Exception) {}
+    }
+  } else {
+    reactContext.startService(intent)
+  }
+
+  val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+    BIND_AUTO_CREATE or BIND_INCLUDE_CAPABILITIES
+  } else {
+    BIND_AUTO_CREATE
+  }
+
+  context.bindService(intent, serviceConnection, flags)
+}
+
+@OptIn(UnstableApi::class)
+fun VideoPlaybackService.Companion.stopService(
+  player: HybridVideoPlayer,
+  serviceConnection: VideoPlaybackServiceConnection
+) {
+  try {
+    // Unregister the player first; this might stop the service if no players remain
+    serviceConnection.unregisterPlayer(player)
+    // Ask service (if still connected) to stop when idle
+    try { serviceConnection.serviceBinder?.service?.stopIfNoPlayers() } catch (_: Exception) {}
+    // Then unbind
+    NitroModules.applicationContext?.currentActivity?.unbindService(serviceConnection)
+  } catch (_: Exception) {}
+}

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

@@ -0,0 +1,265 @@
+package com.twg.video.core.fragments
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.Configuration
+import android.os.Build
+import android.os.Bundle
+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 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.twg.video.core.utils.PictureInPictureUtils.createPictureInPictureParams
+import com.twg.video.core.utils.SmallVideoPlayerOptimizer
+import com.twg.video.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()
+
+  // 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 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) {}
+    }
+  }
+
+  override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
+    super.onPictureInPictureModeChanged(isInPictureInPictureMode)
+
+    if (isInPictureInPictureMode) {
+      videoView.playerView.useController = false
+      videoView.playerView.controllerAutoShow = false
+    } else {
+      videoView.playerView.useController = videoView.useController
+      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 {
+      videoView.playerView.useController = videoView.useController
+      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)
+  }
+
+  @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()
+
+    // Keep controls disabled if in PiP mode - media session creates its own controls for PiP
+    val isInPictureInPictureMode = requireActivity().isInPictureInPictureMode
+    if (isInPictureInPictureMode) {
+      videoView.playerView.useController = false
+    } else if (videoView.useController == false) {
+      videoView.playerView.useController = 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/twg/video/core/fragments/PictureInPictureHelperFragment.kt

@@ -0,0 +1,85 @@
+package com.twg.video.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.twg.video.core.VideoManager
+import com.twg.video.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("ReactNativeVideo", "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/twg/video/core/player/DRMManagerSpec.kt

@@ -0,0 +1,23 @@
+package com.twg.video.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.video.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/twg/video/core/player/DataSourceFactoryUtils.kt

@@ -0,0 +1,80 @@
+package com.twg.video.core.player
+
+import android.content.Context
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+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.video.HybridVideoPlayerSourceSpec
+import okhttp3.JavaNetCookieJar
+import androidx.media3.datasource.cronet.CronetDataSource
+import com.margelo.nitro.nitrofetch.NitroFetch
+import java.util.concurrent.Executors
+
+const val DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0" 
+
+fun buildBaseDataSourceFactory(context: Context, source: HybridVideoPlayerSourceSpec): DefaultDataSource.Factory {
+  return if (source.uri.startsWith("http")) {
+  DefaultDataSource.Factory(
+    context,
+    if (source.config.forceOkhttp == true) {
+      buildHttpDataSourceFactory(context, source)
+    } else {
+      buildCronetHttpDataSourceFactory(source)
+    }
+  )
+  } else {
+    DefaultDataSource.Factory(context)
+  }
+}
+
+@OptIn(UnstableApi::class)
+fun buildHttpDataSourceFactory(context: Context, source: HybridVideoPlayerSourceSpec): OkHttpDataSource.Factory {
+  val client = OkHttpClientProvider.getOkHttpClient()
+
+  if (context is ReactContext) {
+    val handler = ForwardingCookieHandler(context)
+    (client.cookieJar as CookieJarContainer).setCookieJar(JavaNetCookieJar(handler))
+  }
+
+  val factory = OkHttpDataSource.Factory(client)
+
+  val headers: Map<String, String>? = source.config.headers
+
+  if (headers != null) {
+    factory.setDefaultRequestProperties(headers)
+  }
+
+  if (headers == null || !headers.containsKey("User-Agent")) {
+    factory.setUserAgent(DEFAULT_USER_AGENT)
+  }
+
+  return factory
+}
+
+@OptIn(UnstableApi::class)
+fun buildCronetHttpDataSourceFactory(source: HybridVideoPlayerSourceSpec): CronetDataSource.Factory {
+  // Get Cronet engine and executor from NitroFetch
+  // used before NitroFetch.ioExecutor , but cause blocking thread
+  val factory = CronetDataSource.Factory(NitroFetch.getEngine(), Executors.newSingleThreadExecutor())
+    .setConnectionTimeoutMs(10_000)
+    .setReadTimeoutMs(10_000)
+    .setResetTimeoutOnRedirects(true)
+    .setHandleSetCookieRequests(true)
+
+  val headers: Map<String, String>? = source.config.headers
+
+  if (headers != null) {
+    factory.setDefaultRequestProperties(headers)
+  }
+
+  if (headers == null || !headers.containsKey("User-Agent")) {
+    factory.setUserAgent(DEFAULT_USER_AGENT)
+  }
+
+  return factory
+}