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

package/android/src/main/java/com/twg/video/core/utils/SmallVideoPlayerOptimizer.kt

@@ -0,0 +1,157 @@
+package com.twg.video.core.utils
+
+import android.content.Context
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ImageButton
+import androidx.media3.ui.PlayerView
+
+object SmallVideoPlayerOptimizer {
+
+  fun isSmallVideoPlayer(playerView: PlayerView): Boolean {
+    // Check if the PlayerView dimensions are small enough to warrant optimizations
+    val width = playerView.width
+    val height = playerView.height
+
+    // If view hasn't been measured yet, use layout params or return false
+    if (width <= 0 || height <= 0) {
+      val layoutParams = playerView.layoutParams
+      if (layoutParams != null) {
+        // Convert any specific dimensions to pixels if needed
+        val widthPx = if (layoutParams.width > 0) layoutParams.width else playerView.measuredWidth
+        val heightPx = if (layoutParams.height > 0) layoutParams.height else playerView.measuredHeight
+
+        if (widthPx <= 0 || heightPx <= 0) return false
+
+        return isSmallDimensions(widthPx, heightPx, playerView.context)
+      }
+      return false
+    }
+
+    return isSmallDimensions(width, height, playerView.context)
+  }
+
+  private fun isSmallDimensions(widthPx: Int, heightPx: Int, context: Context): Boolean {
+    val density = context.resources.displayMetrics.density
+    val widthDp = widthPx / density
+    val heightDp = heightPx / density
+
+    // Consider the video player "small" if width <= 400dp or height <= 300dp
+    // These thresholds are more appropriate for actual video player sizes
+    return widthDp <= 400 || heightDp <= 300
+  }
+
+  fun applyOptimizations(
+    playerView: PlayerView,
+    context: Context,
+    isFullscreen: Boolean = false
+  ) {
+    playerView.post {
+      try {
+        if (isFullscreen) {
+          // For fullscreen mode, use system defaults - no custom optimizations
+          // Let ExoPlayer use its default controller timeout and styling
+          return@post
+        }
+
+        // Only apply optimizations if the video player itself is small
+        if (!isSmallVideoPlayer(playerView)) {
+          return@post
+        }
+
+        val controllerView = playerView.findViewById<ViewGroup>(androidx.media3.ui.R.id.exo_controller)
+        controllerView?.let { controller ->
+          optimizeControlElementsForSmallPlayer(controller, context)
+        }
+      } catch (e: Exception) {
+        Log.w("ReactNativeVideo", "Error applying small video player optimizations: ${e.message}")
+      }
+    }
+  }
+
+  private fun optimizeControlElementsForSmallPlayer(
+    controller: ViewGroup,
+    context: Context
+  ) {
+    val density = context.resources.displayMetrics.density
+    val primaryButtonSize = (48 * density).toInt()
+    val secondaryButtonSize = (44 * density).toInt()
+
+    optimizeButtons(controller, primaryButtonSize, secondaryButtonSize)
+    optimizeProgressBar(controller, context)
+    optimizeTextElements(controller)
+  }
+
+  private fun optimizeButtons(
+    container: ViewGroup,
+    primarySize: Int,
+    secondarySize: Int
+  ) {
+    for (i in 0 until container.childCount) {
+      val child = container.getChildAt(i)
+      when (child) {
+        is ImageButton -> {
+          val buttonSize = when (child.id) {
+            androidx.media3.ui.R.id.exo_play_pause -> primarySize
+            androidx.media3.ui.R.id.exo_fullscreen -> primarySize
+            androidx.media3.ui.R.id.exo_settings -> primarySize
+            androidx.media3.ui.R.id.exo_rew -> secondarySize
+            androidx.media3.ui.R.id.exo_ffwd -> secondarySize
+            androidx.media3.ui.R.id.exo_subtitle -> secondarySize
+            androidx.media3.ui.R.id.exo_prev -> secondarySize
+            androidx.media3.ui.R.id.exo_next -> secondarySize
+            else -> secondarySize
+          }
+
+          val params = child.layoutParams
+          params.width = buttonSize
+          params.height = buttonSize
+          child.layoutParams = params
+
+          // Hide less essential buttons on small video players
+          when (child.id) {
+            androidx.media3.ui.R.id.exo_shuffle,
+            androidx.media3.ui.R.id.exo_repeat_toggle,
+            androidx.media3.ui.R.id.exo_vr -> {
+              child.visibility = View.GONE
+            }
+          }
+        }
+        is ViewGroup -> {
+          optimizeButtons(child, primarySize, secondarySize)
+        }
+      }
+    }
+  }
+
+  private fun optimizeProgressBar(
+    controller: ViewGroup,
+    context: Context
+  ) {
+    val progressContainer = controller.findViewById<View>(androidx.media3.ui.R.id.exo_progress)
+    progressContainer?.let { progress ->
+      val params = progress.layoutParams as? ViewGroup.MarginLayoutParams
+      params?.let {
+        it.height = (4 * context.resources.displayMetrics.density).toInt()
+        progress.layoutParams = it
+      }
+    }
+  }
+
+  private fun optimizeTextElements(
+    controller: ViewGroup
+  ) {
+    val timeContainer = controller.findViewById<ViewGroup>(androidx.media3.ui.R.id.exo_time)
+    timeContainer?.let { time ->
+      val positionView = time.findViewById<View>(androidx.media3.ui.R.id.exo_position)
+      val durationView = time.findViewById<View>(androidx.media3.ui.R.id.exo_duration)
+
+      listOf(positionView, durationView).forEach { textView ->
+        if (textView is android.widget.TextView) {
+          textView.textSize = 12f
+        }
+      }
+    }
+  }
+}

package/android/src/main/java/com/twg/video/core/utils/SourceLoader.kt

@@ -0,0 +1,48 @@
+package com.twg.video.core.utils
+
+import com.twg.video.core.SourceError
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicReference
+
+class SourceLoader {
+  private val operationCounter = AtomicInteger(0)
+  private val currentOperationRef = AtomicReference<OperationHolder<*>?>(null)
+
+  fun <T> load(operation: () -> T): T {
+    cancel()
+
+    val currentOp = operationCounter.incrementAndGet()
+    val holder = OperationHolder<T>(currentOp)
+    currentOperationRef.set(holder)
+
+    return try {
+      val result = operation()
+      if (holder.operationId != operationCounter.get()) {
+        throw SourceError.Cancelled
+      }
+      result
+    } catch (e: SourceError.Cancelled) {
+      throw e
+    } catch (e: Exception) {
+      if (holder.operationId != operationCounter.get()) {
+        throw SourceError.Cancelled
+      }
+      throw e
+    } finally {
+      if (holder.operationId == operationCounter.get()) {
+        currentOperationRef.set(null)
+      }
+    }
+  }
+
+  fun cancel() {
+    val current = currentOperationRef.get()
+    if (current != null) {
+      operationCounter.incrementAndGet()
+      currentOperationRef.set(null)
+    }
+  }
+
+  private class OperationHolder<T>(val operationId: Int)
+}
+

package/android/src/main/java/com/twg/video/core/utils/Threading.kt

@@ -0,0 +1,75 @@
+package com.twg.video.core.utils
+
+import android.os.Handler
+import android.os.Looper
+import com.margelo.nitro.NitroModules
+import com.twg.video.core.LibraryError
+import java.util.concurrent.Callable
+import java.util.concurrent.FutureTask
+import kotlin.reflect.KProperty
+
+object Threading {
+  @JvmStatic
+  fun runOnMainThread(action: () -> Unit) {
+    // We are already on the main thread, run and return
+    if (Looper.myLooper() == Looper.getMainLooper()) {
+      action()
+      return
+    }
+
+    // If application context is null, throw an error
+    if (NitroModules.applicationContext == null) {
+      throw LibraryError.ApplicationContextNotFound
+    }
+
+    // Post the action to the main thread
+    Handler(NitroModules.applicationContext!!.mainLooper).post {
+      action()
+    }
+  }
+
+  @JvmStatic
+  fun <T> runOnMainThreadSync(action: Callable<T>): T {
+    return if (Looper.myLooper() == Looper.getMainLooper()) {
+      // Already on the main thread, run and return the result
+      action.call()
+    } else {
+      // Post the action to the main thread and wait for the result
+      val futureTask = FutureTask(action)
+      Handler(Looper.getMainLooper()).post(futureTask)
+      futureTask.get()
+    }
+  }
+
+  class MainThreadProperty<Reference, Type>(
+    private val get: Reference.() -> Type,
+    private val set: (Reference.(Type) -> Unit)? = null
+  ) {
+    operator fun getValue(thisRef: Reference, property: KProperty<*>): Type {
+      return runOnMainThreadSync { thisRef.get() }
+    }
+
+    operator fun setValue(thisRef: Reference, property: KProperty<*>, value: Type) {
+      val setter = set ?: throw IllegalStateException("Property ${property.name} is read-only")
+      runOnMainThread { thisRef.setter(value) }
+    }
+  }
+
+  /**
+   * Read-only property that runs on main thread
+   * @param get The getter function that runs synchronously on the main thread.
+   *
+   * @throws [IllegalStateException] if there will be a write operation
+   */
+  fun <Reference, T> Reference.mainThreadProperty(get: Reference.() -> T) = MainThreadProperty(get)
+
+  /**
+   * Read-only property that runs on main thread
+   * @param get The getter function that runs synchronously on the main thread
+   * @param set The setter function that runs asynchronously on the main thread
+   */
+  fun <Reference, T> Reference.mainThreadProperty(
+    get: Reference.() -> T,
+    set: Reference.(T) -> Unit
+  ) = MainThreadProperty(get, set)
+}

package/android/src/main/java/com/twg/video/core/utils/TrackUtils.kt

@@ -0,0 +1,305 @@
+package com.twg.video.core.utils
+
+import androidx.media3.common.Format
+import androidx.media3.common.C
+import androidx.media3.common.TrackSelectionOverride
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import com.margelo.nitro.video.HybridVideoPlayerSourceSpec
+import com.margelo.nitro.video.PlayerTrack
+import com.margelo.nitro.video.AllPlayerTracks
+import com.margelo.nitro.video.VideoPlayerTrack
+
+@UnstableApi
+object TrackUtils {
+    fun getAvailableTextTracks(player: ExoPlayer, source: HybridVideoPlayerSourceSpec): Array<PlayerTrack> {
+        return Threading.runOnMainThreadSync {
+            val tracks = mutableListOf<PlayerTrack>()
+            val currentTracks = player.currentTracks
+            var globalTrackIndex = 0
+
+            // Get all text tracks from the current player tracks (includes both built-in and external)
+            for (trackGroup in currentTracks.groups) {
+                if (trackGroup.type == C.TRACK_TYPE_TEXT) {
+                    for (trackIndex in 0 until trackGroup.length) {
+                        val format = trackGroup.getTrackFormat(trackIndex)
+                        val trackId = format.id ?: "track-${C.TRACK_TYPE_TEXT}-$globalTrackIndex"
+                        val label = format.label ?: "Unknown ${globalTrackIndex + 1}"
+                        val language = format.language
+                        val isSelected = trackGroup.isTrackSelected(trackIndex)
+
+                        val isExternal = trackId.startsWith("external-") == true
+
+                        val finalTrackId = if (isExternal) "external-$globalTrackIndex" else trackId
+
+                        tracks.add(
+                            PlayerTrack(
+                                id = finalTrackId,
+                                label = label,
+                                language = language,
+                                selected = isSelected
+                            )
+                        )
+                        
+                        globalTrackIndex++
+                    }
+                }
+            }
+
+            tracks.toTypedArray()
+        }
+    }
+
+    fun selectTrackById(
+        player: ExoPlayer,
+        type: Int,
+        id: String?
+    ) {
+        return Threading.runOnMainThreadSync {
+            val trackSelector = player.trackSelectionParameters.buildUpon()
+
+            if (id == null || id.isEmpty()) {
+                trackSelector.setTrackTypeDisabled(type, true)
+                player.trackSelectionParameters = trackSelector.build()
+                return@runOnMainThreadSync
+            }
+
+            val currentTracks = player.currentTracks
+            var trackFound = false
+            var globalTrackIndex = 0
+
+            for (trackGroup in currentTracks.groups) {
+                if (trackGroup.type == type) {
+                    for (trackIndex in 0 until trackGroup.length) {
+                        val format = trackGroup.getTrackFormat(trackIndex)
+                        val currentTrackId = format.id ?: "track-$type-$globalTrackIndex"
+                        //val label = format.label ?: "Unknown ${globalTrackIndex + 1}"
+
+                        val isExternal = currentTrackId.startsWith("external-") == true
+
+                        val finalTrackId =
+                            if (isExternal) "external-$globalTrackIndex" else currentTrackId
+
+                        if (finalTrackId == id) {
+                            // Enable this specific track
+                            trackSelector.setTrackTypeDisabled(type, false)
+                            trackSelector.setOverrideForType(
+                                TrackSelectionOverride(
+                                    trackGroup.mediaTrackGroup,
+                                    listOf(trackIndex)
+                                )
+                            )
+
+                            trackFound = true
+                            break
+                        }
+                        
+                        globalTrackIndex++
+                    }
+                    if (trackFound) {
+                        break
+                    }
+                }
+            }
+
+            // Apply the track selection parameters regardless of whether we found a track
+            player.trackSelectionParameters = trackSelector.build()
+        }
+    }
+
+     fun selectTrackByIndex(
+        player: ExoPlayer,
+        type: Int,
+        index: Int?
+    ) {
+        return Threading.runOnMainThreadSync {
+            val trackSelector = player.trackSelectionParameters.buildUpon()
+
+            if (index == null) {
+                trackSelector.setTrackTypeDisabled(type, true)
+                player.trackSelectionParameters = trackSelector.build()
+                return@runOnMainThreadSync
+            }
+
+            val currentTracks = player.currentTracks
+            var trackFound = false
+            var globalTrackIndex = 0
+
+            for (trackGroup in currentTracks.groups) {
+                if (trackGroup.type == type) {
+                    for (trackIndex in 0 until trackGroup.length) {
+                        if (index == globalTrackIndex) {
+                            // Enable this specific track
+                            trackSelector.setTrackTypeDisabled(type, false)
+                            trackSelector.setOverrideForType(
+                                TrackSelectionOverride(
+                                    trackGroup.mediaTrackGroup,
+                                    listOf(trackIndex)
+                                )
+                            )
+
+                            trackFound = true
+                            break
+                        }
+                        
+                        globalTrackIndex++
+                    }
+                    if (trackFound) {
+                        break
+                    }
+                }
+            }
+
+            // Apply the track selection parameters regardless of whether we found a track
+            player.trackSelectionParameters = trackSelector.build()
+        }
+    }
+
+    fun getTextSelectedTrack(player: ExoPlayer): PlayerTrack? {
+        return Threading.runOnMainThreadSync {
+            val currentTracks = player.currentTracks
+            var globalTrackIndex = 0
+
+            // Find the currently selected text track
+            for (trackGroup in currentTracks.groups) {
+                if (trackGroup.type == C.TRACK_TYPE_TEXT && trackGroup.isSelected) {
+                    for (trackIndex in 0 until trackGroup.length) {
+                        if (trackGroup.isTrackSelected(trackIndex)) {
+                            val format = trackGroup.getTrackFormat(trackIndex)
+                            val trackId = format.id ?: "track-${C.TRACK_TYPE_TEXT}-$globalTrackIndex"
+                            val label = format.label ?: "Unknown ${globalTrackIndex + 1}"
+                            val language = format.language
+
+                            val isExternal = trackId.startsWith("external-") == true
+
+                            val finalTrackId = if (isExternal) "external-$globalTrackIndex" else trackId
+
+                            return@runOnMainThreadSync PlayerTrack(
+                                id = finalTrackId,
+                                label = label,
+                                language = language,
+                                selected = true
+                            )
+                        }
+                        globalTrackIndex++
+                    }
+                } else if (trackGroup.type == C.TRACK_TYPE_TEXT) {
+                    // Still need to increment global index for non-selected text track groups
+                    globalTrackIndex += trackGroup.length
+                }
+            }
+
+            null
+        }
+    }
+
+    fun getAllPlayerTracksInternal(player: ExoPlayer): AllPlayerTracks {
+            val audioTracks = mutableListOf<PlayerTrack>()
+            val textTracks = mutableListOf<PlayerTrack>()
+            val videoTracks = mutableListOf<VideoPlayerTrack>()
+
+            val currentTracks = player.currentTracks
+
+            var globalAudioIndex = 0
+            var globalTextIndex = 0
+            var globalVideoIndex = 0
+
+            for (trackGroup in currentTracks.groups) {
+                when (trackGroup.type) {
+                    C.TRACK_TYPE_AUDIO -> {
+                        for (trackIndex in 0 until trackGroup.length) {
+                            val format = trackGroup.getTrackFormat(trackIndex)
+
+                            val rawId = format.id ?: "track-${C.TRACK_TYPE_AUDIO}-$globalAudioIndex"
+                            val isExternal = rawId.startsWith("external-")
+                            val finalId = if (isExternal) "external-$globalAudioIndex" else rawId
+
+                            val label = format.label ?: "Unknown ${globalAudioIndex + 1}"
+                            val language = format.language
+                            val isSelected = trackGroup.isTrackSelected(trackIndex)
+
+                            audioTracks.add(
+                                PlayerTrack(
+                                    id = finalId,
+                                    label = label,
+                                    language = language,
+                                    selected = isSelected
+                                )
+                            )
+
+                            globalAudioIndex++
+                        }
+                    }
+                    C.TRACK_TYPE_TEXT -> {
+                        for (trackIndex in 0 until trackGroup.length) {
+                            val format = trackGroup.getTrackFormat(trackIndex)
+
+                            val rawId = format.id ?: "track-${C.TRACK_TYPE_TEXT}-$globalTextIndex"
+                            val isExternal = rawId.startsWith("external-")
+                            val finalId = if (isExternal) "external-$globalTextIndex" else rawId
+
+                            val label = format.label ?: "Unknown ${globalTextIndex + 1}"
+                            val language = format.language
+                            val isSelected = trackGroup.isTrackSelected(trackIndex)
+
+                            textTracks.add(
+                                PlayerTrack(
+                                    id = finalId,
+                                    label = label,
+                                    language = language,
+                                    selected = isSelected
+                                )
+                            )
+
+                            globalTextIndex++
+                        }
+                    }
+
+                    C.TRACK_TYPE_VIDEO -> {
+                        for (trackIndex in 0 until trackGroup.length) {
+                            val format = trackGroup.getTrackFormat(trackIndex)
+
+                            val rawId = format.id ?: "track-${C.TRACK_TYPE_VIDEO}-$globalVideoIndex"
+                            val isExternal = rawId.startsWith("external-")
+                            val finalId = if (isExternal) "external-$globalVideoIndex" else rawId
+
+                            val label = format.label ?: "Unknown ${globalVideoIndex + 1}"
+                            val language = format.language
+                            val isSelected = trackGroup.isTrackSelected(trackIndex)
+
+                            val width = if (format.width != Format.NO_VALUE) format.width.toDouble() else 0.0
+                            val height = if (format.height != Format.NO_VALUE) format.height.toDouble() else 0.0
+
+                            videoTracks.add(
+                                VideoPlayerTrack(
+                                    width = width,
+                                    height = height,
+                                    id = finalId,
+                                    label = label,
+                                    language = language,
+                                    selected = isSelected
+                                )
+                            )
+
+                            globalVideoIndex++
+                        }
+                    }
+
+                    else -> Unit
+                }
+            }
+
+        return AllPlayerTracks(
+                audios = audioTracks.toTypedArray(),
+                videos = videoTracks.toTypedArray(),
+                texts = textTracks.toTypedArray()
+            )
+    }
+
+    fun getAllPlayerTracks(player: ExoPlayer): AllPlayerTracks {
+        return Threading.runOnMainThreadSync {
+            getAllPlayerTracksInternal(player)
+        }
+    }
+
+}

package/android/src/main/java/com/twg/video/core/utils/VideoFileHelper.kt

@@ -0,0 +1,51 @@
+package com.twg.video.core.utils
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.webkit.URLUtil
+import com.margelo.nitro.NitroModules
+import com.twg.video.core.SourceError
+import java.io.File
+import java.net.URL
+import java.net.URLConnection
+
+object VideoFileHelper {
+  private fun hasReadPermission(): Boolean {
+    return NitroModules.applicationContext?.checkSelfPermission(
+      Manifest.permission.READ_EXTERNAL_STORAGE
+    ) == PackageManager.PERMISSION_GRANTED
+  }
+
+  fun validateReadPermission(uri: String) {
+    if (!hasReadPermission()) throw SourceError.MissingReadFilePermission(uri)
+
+    val file = File(Uri.parse(uri).path ?: throw SourceError.InvalidUri(uri))
+
+    // Check if file exists and is readable
+    if (!file.exists()) throw SourceError.FileDoesNotExist(uri)
+
+    // Check if file is readable
+    if (!file.canRead()) throw SourceError.MissingReadFilePermission(uri)
+  }
+
+  fun getFileSizeFromUri(uri: String): Long {
+    return try {
+      when {
+        URLUtil.isFileUrl(uri) -> {
+          validateReadPermission(uri)
+          val file = File(Uri.parse(uri).path ?: return -1)
+          if (file.exists()) file.length() else -1
+        }
+        URLUtil.isNetworkUrl(uri) -> {
+          val connection: URLConnection = URL(uri).openConnection()
+          connection.connect()
+          connection.contentLength.toLong()
+        }
+        else -> -1
+      }
+    } catch (e: Exception) {
+      -1
+    }
+  }
+}