spactureai-mobile-player 1.0.30

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

@@ -0,0 +1,157 @@
+package com.unifiedplayer.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("UnifiedPlayer", "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/unifiedplayer/core/utils/SourceLoader.kt

@@ -0,0 +1,48 @@
+package com.unifiedplayer.core.utils
+
+import com.unifiedplayer.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/unifiedplayer/core/utils/TextTrackUtils.kt

@@ -0,0 +1,175 @@
+package com.unifiedplayer.core.utils
+
+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.unifiedplayer.HybridVideoPlayerSourceSpec
+import com.margelo.nitro.unifiedplayer.TextTrack
+
+@UnstableApi
+object TextTrackUtils {
+    fun getAvailableTextTracks(player: ExoPlayer, source: HybridVideoPlayerSourceSpec): Array<TextTrack> {
+        return Threading.runOnMainThreadSync {
+            val tracks = mutableListOf<TextTrack>()
+            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 ?: "text-$globalTrackIndex"
+                        val label = format.label ?: "Unknown ${globalTrackIndex + 1}"
+                        val language = format.language
+                        val isSelected = trackGroup.isTrackSelected(trackIndex)
+
+                        // Determine if this is an external track by checking if it matches external subtitle labels
+                        val isExternal = source.config.externalSubtitles?.any { subtitle ->
+                            label.contains(subtitle.label, ignoreCase = true)
+                        } == true
+
+                        val finalTrackId = if (isExternal) "external-$globalTrackIndex" else trackId
+
+                        tracks.add(
+                            TextTrack(
+                                id = finalTrackId,
+                                label = label,
+                                language = language,
+                                selected = isSelected
+                            )
+                        )
+                        
+                        globalTrackIndex++
+                    }
+                }
+            }
+
+            tracks.toTypedArray()
+        }
+    }
+
+    fun selectTextTrack(
+        player: ExoPlayer,
+        textTrack: TextTrack?,
+        source: HybridVideoPlayerSourceSpec,
+        onTrackChange: (TextTrack?) -> Unit,
+    ): Int? {
+        return Threading.runOnMainThreadSync {
+            val trackSelector = player.trackSelectionParameters.buildUpon()
+
+            // If textTrack is null, disable all text tracks
+            if (textTrack == null) {
+                trackSelector.setTrackTypeDisabled(C.TRACK_TYPE_TEXT, true)
+                player.trackSelectionParameters = trackSelector.build()
+                onTrackChange(null)
+                return@runOnMainThreadSync null
+            }
+
+            if (textTrack.id.isEmpty()) {
+                // Disable all text tracks
+                trackSelector.setTrackTypeDisabled(C.TRACK_TYPE_TEXT, true)
+                player.trackSelectionParameters = trackSelector.build()
+                onTrackChange(null)
+                return@runOnMainThreadSync null
+            }
+
+            val currentTracks = player.currentTracks
+            var trackFound = false
+            var selectedExternalTrackIndex: Int? = null
+            var globalTrackIndex = 0
+
+            // Find and select the specific text track
+            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 currentTrackId = format.id ?: "text-$globalTrackIndex"
+                        val label = format.label ?: "Unknown ${globalTrackIndex + 1}"
+
+                        // Check if this matches our target track (either by original ID or by external ID)
+                        val isExternal = source.config.externalSubtitles?.any { subtitle ->
+                            label.contains(subtitle.label, ignoreCase = true)
+                        } == true
+
+                        val finalTrackId =
+                            if (isExternal) "external-$globalTrackIndex" else currentTrackId
+
+                        if (finalTrackId == textTrack.id) {
+                            // Enable this specific track
+                            trackSelector.setTrackTypeDisabled(C.TRACK_TYPE_TEXT, false)
+                            trackSelector.setOverrideForType(
+                                TrackSelectionOverride(
+                                    trackGroup.mediaTrackGroup,
+                                    listOf(trackIndex)
+                                )
+                            )
+
+                            // Update selection state
+                            selectedExternalTrackIndex = if (isExternal) {
+                                globalTrackIndex
+                            } else {
+                                null
+                            }
+
+                            onTrackChange(textTrack)
+                            trackFound = true
+                            break
+                        }
+                        
+                        globalTrackIndex++
+                    }
+                    if (trackFound) {
+                        break
+                    }
+                }
+            }
+
+            // Apply the track selection parameters regardless of whether we found a track
+            player.trackSelectionParameters = trackSelector.build()
+            selectedExternalTrackIndex
+        }
+    }
+
+    fun getSelectedTrack(player: ExoPlayer, source: HybridVideoPlayerSourceSpec): TextTrack? {
+        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 ?: "text-$globalTrackIndex"
+                            val label = format.label ?: "Unknown ${globalTrackIndex + 1}"
+                            val language = format.language
+
+                            // Determine if this is an external track by checking if it matches external subtitle labels
+                            val isExternal = source.config.externalSubtitles?.any { subtitle ->
+                                label.contains(subtitle.label, ignoreCase = true)
+                            } == true
+
+                            val finalTrackId = if (isExternal) "external-$globalTrackIndex" else trackId
+
+                            return@runOnMainThreadSync TextTrack(
+                                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
+        }
+    }
+}

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

@@ -0,0 +1,75 @@
+package com.unifiedplayer.core.utils
+
+import android.os.Handler
+import android.os.Looper
+import com.margelo.nitro.NitroModules
+import com.unifiedplayer.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/unifiedplayer/core/utils/VideoFileHelper.kt

@@ -0,0 +1,51 @@
+package com.unifiedplayer.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.unifiedplayer.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
+    }
+  }
+}

package/android/src/main/java/com/unifiedplayer/core/utils/VideoInformationUtils.kt

@@ -0,0 +1,67 @@
+package com.unifiedplayer.core.utils
+
+import android.media.MediaFormat
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.os.Build
+import android.webkit.URLUtil
+import com.margelo.nitro.unifiedplayer.VideoInformation
+import androidx.core.net.toUri
+
+object VideoInformationUtils {
+  fun fromUri(uri: String, headers: Map<String, String> = emptyMap()): VideoInformation {
+    val retriever = MediaMetadataRetriever()
+
+    when {
+      URLUtil.isFileUrl(uri) -> {
+        retriever.setDataSource(uri.toUri().path)
+      }
+      else -> {
+        retriever.setDataSource(uri, headers)
+      }
+    }
+
+    // Get dimensions
+    val width = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)?.toDoubleOrNull() ?: Double.NaN
+    val height = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)?.toDoubleOrNull() ?: Double.NaN
+
+    // Get duration in milliseconds, convert to long
+    val duration = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toLongOrNull() ?: -1L
+
+    // If we have some valid info, but there is no duration it might be live
+    val isLive = !width.isNaN() && !height.isNaN() && duration <= 0
+
+    // Get bitrate
+    val bitrate = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)?.toDoubleOrNull() ?: Double.NaN
+
+    // Get rotation
+    val rotation = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION)?.toIntOrNull() ?: 0
+
+    // Check for HDR by looking at color transfer (API 30+)
+    val isHDR = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      val colorTransfer = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COLOR_TRANSFER)?.toIntOrNull()
+      colorTransfer == MediaFormat.COLOR_TRANSFER_ST2084 || colorTransfer == MediaFormat.COLOR_TRANSFER_HLG
+    } else {
+      false
+    }
+
+    // Clean up
+    retriever.release()
+
+    // Get file size
+    val fileSize = VideoFileHelper.getFileSizeFromUri(uri)
+
+    val videoInfo = VideoInformation(
+      bitrate = bitrate,
+      width = width,
+      height = height,
+      duration = duration,
+      fileSize = fileSize,
+      isHDR = isHDR,
+      isLive = isLive,
+      orientation = VideoOrientationUtils.fromWHR(width.toInt(), height.toInt(), rotation)
+    )
+
+    return videoInfo
+  }
+}

package/android/src/main/java/com/unifiedplayer/core/utils/VideoOrientationUtils.kt

@@ -0,0 +1,30 @@
+package com.unifiedplayer.core.utils
+
+import com.margelo.nitro.unifiedplayer.VideoOrientation
+
+object VideoOrientationUtils {
+  fun fromWHR(width: Int?, height: Int?, rotation: Int?): VideoOrientation {
+    if (width == 0 || height == 0 || height == null || width == null) return VideoOrientation.UNKNOWN
+
+    if (width == height) return VideoOrientation.SQUARE
+
+    // Check if video is portrait or landscape using natural size
+    val isNaturalSizePortrait = height > width
+
+    // If rotation is not available, use natural size to determine orientation
+    if (rotation == null) {
+      return if (isNaturalSizePortrait) VideoOrientation.PORTRAIT else VideoOrientation.LANDSCAPE_RIGHT
+    }
+
+    // Normalize rotation to 0-360 range
+    val normalizedRotation = ((rotation % 360) + 360) % 360
+
+    return when (normalizedRotation) {
+      0 -> if (isNaturalSizePortrait) VideoOrientation.PORTRAIT else VideoOrientation.LANDSCAPE_RIGHT
+      90 -> VideoOrientation.PORTRAIT
+      180 -> if (isNaturalSizePortrait) VideoOrientation.PORTRAIT_UPSIDE_DOWN else VideoOrientation.LANDSCAPE_LEFT
+      270 -> VideoOrientation.PORTRAIT_UPSIDE_DOWN
+      else -> if (isNaturalSizePortrait) VideoOrientation.PORTRAIT else VideoOrientation.LANDSCAPE_RIGHT
+    }
+  }
+}