spactureai-mobile-player 1.0.30

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

@@ -0,0 +1,134 @@
+package com.unifiedplayer.core.player
+
+import android.content.Context
+import android.net.Uri
+import androidx.annotation.OptIn
+import androidx.media3.common.util.Util
+import androidx.media3.exoplayer.source.MediaSource
+import com.margelo.nitro.unifiedplayer.HybridVideoPlayerSourceSpec
+import androidx.core.net.toUri
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.dash.DashMediaSource
+import androidx.media3.exoplayer.drm.DrmSessionManager
+import androidx.media3.exoplayer.hls.DefaultHlsExtractorFactory
+import androidx.media3.exoplayer.hls.HlsMediaSource
+import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
+import androidx.media3.exoplayer.source.MergingMediaSource
+import androidx.media3.extractor.ts.DefaultTsPayloadReaderFactory
+import com.margelo.nitro.unifiedplayer.HybridVideoPlayerSource
+import com.unifiedplayer.core.LibraryError
+import com.unifiedplayer.core.SourceError
+import com.unifiedplayer.core.plugins.PluginsRegistry
+
+@OptIn(UnstableApi::class)
+@Throws(SourceError::class)
+fun buildMediaSource(context: Context, source: HybridVideoPlayerSource, mediaItem: MediaItem): MediaSource {
+  val uri = source.uri.toUri()
+
+  // Explanation:
+  // 1. Remove query params from uri to avoid getting false extension
+  // 2. Get extension from uri
+  val type = Util.inferContentType(uri)
+  val dataSourceFactory = PluginsRegistry.shared.overrideMediaDataSourceFactory(
+    source,
+    buildBaseDataSourceFactory(context, source)
+  )
+
+  if (!source.config.externalSubtitles.isNullOrEmpty()) {
+    return buildExternalSubtitlesMediaSource(context, source)
+  }
+
+  val mediaSourceFactory: MediaSource.Factory = when (type) {
+    C.CONTENT_TYPE_DASH -> {
+      DashMediaSource.Factory(dataSourceFactory)
+    }
+    C.CONTENT_TYPE_HLS -> {
+      // HEVC-friendly HLS extractor:
+      //   FLAG_ALLOW_NON_IDR_KEYFRAMES — H.265 uses CRA/BLA/IDR_N_LP NAL units instead
+      //     of H.264 IDR. Without this flag the TS payload reader can drop the first
+      //     keyframe in HEVC HLS streams, producing audio-only / black-video playback.
+      //   FLAG_DETECT_ACCESS_UNITS — required when the stream lacks AUD NAL units
+      //     between samples, also common in HEVC TS HLS.
+      // Chunkless preparation is DISABLED: the Spacture proxy serves a media-only
+      // playlist (no master with `CODECS="hvc1.*"`), so chunkless prep can't infer
+      // the track format and the renderer initialises against the wrong codec —
+      // black video, looping rebuffer. Forcing first-segment download lets the TS
+      // extractor probe the bitstream and surface HEVC correctly. The one-extra
+      // segment fetch on startup is well worth restoring playback.
+      HlsMediaSource.Factory(dataSourceFactory)
+        .setExtractorFactory(
+          DefaultHlsExtractorFactory(
+            DefaultTsPayloadReaderFactory.FLAG_ALLOW_NON_IDR_KEYFRAMES or
+              DefaultTsPayloadReaderFactory.FLAG_DETECT_ACCESS_UNITS,
+            true
+          )
+        )
+        .setAllowChunklessPreparation(false)
+    }
+    C.CONTENT_TYPE_OTHER -> {
+      DefaultMediaSourceFactory(context)
+        .setDataSourceFactory(dataSourceFactory)
+    }
+    else -> {
+      throw SourceError.UnsupportedContentType(source.uri)
+    }
+  }
+
+  source.config.drm?.let {
+    val drmSessionManager = source.drmSessionManager ?: throw LibraryError.DRMPluginNotFound
+    mediaSourceFactory.setDrmSessionManagerProvider { drmSessionManager }
+  }
+
+  return PluginsRegistry.shared.overrideMediaSourceFactory(
+    source,
+    mediaSourceFactory,
+    dataSourceFactory
+  ).createMediaSource(mediaItem)
+}
+
+@OptIn(UnstableApi::class)
+fun buildExternalSubtitlesMediaSource(context: Context, source: HybridVideoPlayerSource): MediaSource {
+  val dataSourceFactory = PluginsRegistry.shared.overrideMediaDataSourceFactory(
+    source,
+    buildBaseDataSourceFactory(context, source)
+  )
+
+  val mediaItemBuilderWithSubtitles = MediaItem.Builder()
+    .setUri(source.uri.toUri())
+    .setSubtitleConfigurations(getSubtitlesConfiguration(source.config))
+
+  source.config.metadata?.let { metadata ->
+    mediaItemBuilderWithSubtitles.setMediaMetadata(getCustomMetadata(metadata))
+  }
+
+  val mediaItemBuilder = PluginsRegistry.shared.overrideMediaItemBuilder(
+    source,
+    mediaItemBuilderWithSubtitles
+  )
+
+  val mediaSourceFactory = DefaultMediaSourceFactory(context)
+    .setDataSourceFactory(dataSourceFactory)
+
+  if (source.config.drm != null) {
+    if (source.drmManager == null)  {
+      throw LibraryError.DRMPluginNotFound
+    }
+
+    mediaSourceFactory.setDrmSessionManagerProvider {
+      source.drmManager as DrmSessionManager
+    }
+
+    val drmConfiguration = source.drmManager!!.getDRMConfiguration(source.config.drm!!)
+    mediaItemBuilder.setDrmConfiguration(drmConfiguration)
+  }
+
+  return PluginsRegistry.shared.overrideMediaSourceFactory(
+    source,
+    mediaSourceFactory,
+    dataSourceFactory
+  ).createMediaSource(mediaItemBuilder.build())
+}
+
+

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

@@ -0,0 +1,25 @@
+package com.unifiedplayer.core.player
+
+import android.media.AudioManager
+import com.margelo.nitro.unifiedplayer.HybridVideoPlayerEventEmitter
+
+// TODO: We should make VideoFocusManager that will track focus globally for now lets just do simple listener
+class OnAudioFocusChangedListener : AudioManager.OnAudioFocusChangeListener {
+  private var eventEmitter: HybridVideoPlayerEventEmitter? = null
+
+  override fun onAudioFocusChange(focusChange: Int) {
+    when (focusChange) {
+      AudioManager.AUDIOFOCUS_GAIN -> eventEmitter?.onAudioFocusChange(true)
+      AudioManager.AUDIOFOCUS_LOSS -> eventEmitter?.onAudioFocusChange(false)
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> eventEmitter?.onAudioFocusChange(false)
+    }
+  }
+
+  fun setEventEmitter(eventEmitter: HybridVideoPlayerEventEmitter) {
+    this.eventEmitter = eventEmitter
+  }
+
+  fun removeEventEmitter() {
+    this.eventEmitter = null
+  }
+}

package/android/src/main/java/com/unifiedplayer/core/plugins/PluginsRegistry.kt

@@ -0,0 +1,223 @@
+package com.unifiedplayer.core.plugins
+
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.exoplayer.source.MediaSource
+import com.margelo.nitro.unifiedplayer.HybridVideoPlayer
+import com.margelo.nitro.unifiedplayer.HybridVideoPlayerSource
+import com.unifiedplayer.BuildConfig
+import com.unifiedplayer.core.LibraryError
+import com.unifiedplayer.core.player.DRMManagerSpec
+import com.unifiedplayer.view.VideoView
+import java.lang.ref.WeakReference
+
+// Keep these types for platform compatibility
+// On iOS we cannot just export HybridVideoPlayer so we need to keep this typealias
+typealias NativeVideoPlayer = HybridVideoPlayer
+typealias NativeVideoPlayerSource = HybridVideoPlayerSource
+
+class PluginsRegistry {
+  // Plugin ID -> ReactNativeVideoPluginSpec
+  private val plugins: MutableMap<String, ReactNativeVideoPluginSpec> = mutableMapOf()
+
+  companion object {
+    val shared = PluginsRegistry()
+    private const val TAG = "UnifiedPlayerPluginsRegistry"
+  }
+
+  // Public methods
+  fun register(plugin: ReactNativeVideoPluginSpec) {
+    if(hasPlugin(plugin)) {
+      plugins.replace(plugin.id, plugin)
+
+      if (BuildConfig.DEBUG) {
+        Log.d(TAG, "Replaced plugin ${plugin.name} (ID: ${plugin.id})")
+      }
+
+      return
+    }
+
+    plugins.put(plugin.id, plugin)
+
+    if (BuildConfig.DEBUG) {
+      Log.d(TAG, "Registered plugin ${plugin.name} (ID: ${plugin.id})")
+    }
+  }
+
+  @Suppress("unused")
+  fun unregister(plugin: ReactNativeVideoPluginSpec) {
+    if (!hasPlugin(plugin)) {
+      if (BuildConfig.DEBUG) {
+        Log.d(TAG, "Tried to unregister plugin ${plugin.name} (ID: ${plugin.id}), but it was not registered")
+      }
+
+      return
+    }
+
+    plugins.remove(plugin.id)
+
+    if (BuildConfig.DEBUG) {
+      Log.d(TAG, "Unregistered plugin ${plugin.name} (ID: ${plugin.id})")
+    }
+  }
+
+  // Notifications
+  @OptIn(UnstableApi::class)
+  internal fun notifyPlayerCreated(player: WeakReference<NativeVideoPlayer>) {
+    plugins.values.forEach { it.onPlayerCreated(player) }
+  }
+
+  @OptIn(UnstableApi::class)
+  internal fun notifyPlayerDestroyed(player: WeakReference<NativeVideoPlayer>) {
+    plugins.values.forEach { it.onPlayerDestroyed(player) }
+  }
+
+  @OptIn(UnstableApi::class)
+  internal fun notifyVideoViewCreated(view: WeakReference<VideoView>) {
+    plugins.values.forEach { it.onVideoViewCreated(view) }
+  }
+
+  @OptIn(UnstableApi::class)
+  internal fun notifyVideoViewDestroyed(view: WeakReference<VideoView>) {
+    plugins.values.forEach { it.onVideoViewDestroyed(view) }
+  }
+
+  // Internal methods
+
+  /**
+   * Maybe override the source with the plugins.
+   * 
+   * This method is used to override the source with the plugins.
+   * It is called when a source is created and is used to override the source with the plugins.
+   * 
+   * It is not guaranteed that the source will be overridden with the plugins.
+   * If no plugin overrides the source, the original source is returned.
+   *
+   * @param source The source instance.
+   * @return The maybe overridden source instance.
+   */
+  internal fun overrideSource(source: NativeVideoPlayerSource): NativeVideoPlayerSource {
+    var overriddenSource = source
+
+    for (plugin in plugins.values) {
+      overriddenSource = plugin.overrideSource(overriddenSource)
+    }
+
+    return overriddenSource
+  }
+
+  /**
+   * Returns the DRM manager instance from the plugins.
+   *
+   * @throws LibraryError.DRMPluginNotFound If no DRM manager is found.
+   * @return Any
+   */
+   internal fun getDRMManager(source: NativeVideoPlayerSource): DRMManagerSpec {
+    for (plugin in plugins.values) {
+      val manager = plugin.getDRMManager(source)
+
+      if (manager != null) return manager
+    }
+
+    throw LibraryError.DRMPluginNotFound
+  }
+
+  /**
+   * Maybe override the media data source factory with the plugins.
+   *
+   * If no plugin overrides the media data source factory, the original factory is returned.
+   *
+   * @param source The source instance.
+   * @param mediaDataSourceFactory The media data source factory instance.
+   * @return The maybe overridden media data source factory instance.
+   */
+  internal fun overrideMediaDataSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaDataSourceFactory: DataSource.Factory
+  ): DataSource.Factory {
+    for (plugin in plugins.values) {
+      val factory = plugin.getMediaDataSourceFactory(source, mediaDataSourceFactory)
+
+      if (factory != null) return factory
+    }
+
+    return mediaDataSourceFactory
+  }
+
+  /**
+   * Maybe override the media source factory with the plugins.
+   *
+   * If no plugin overrides the media source factory, the original factory is returned.
+   *
+   * @param source The source instance.
+   * @param mediaSourceFactory The media source factory instance.
+   * @param mediaDataSourceFactory The media data source factory instance.
+   * @return The maybe overridden media source factory instance.
+   */
+  internal fun overrideMediaSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaSourceFactory: MediaSource.Factory,
+    mediaDataSourceFactory: DataSource.Factory
+  ): MediaSource.Factory {
+    for (plugin in plugins.values) {
+      val factory = plugin.getMediaSourceFactory(source, mediaSourceFactory, mediaDataSourceFactory)
+
+      if (factory != null) return factory
+    }
+
+    return mediaSourceFactory
+  }
+
+  /**
+   * Maybe override the media item builder with the plugins.
+   *
+   * If no plugin overrides the media item builder, the original builder is returned.
+   *
+   * @param source The source instance.
+   * @param mediaItemBuilder The media item builder instance.
+   * @return The maybe overridden media item builder instance.
+   */
+  internal fun overrideMediaItemBuilder(
+    source: NativeVideoPlayerSource,
+    mediaItemBuilder: MediaItem.Builder
+  ): MediaItem.Builder {
+    for (plugin in plugins.values) {
+      val builder = plugin.getMediaItemBuilder(source, mediaItemBuilder)
+
+      if (builder != null) return builder
+    }
+
+    return mediaItemBuilder
+  }
+
+  /**
+   * Maybe disable the cache with the plugins.
+   *
+   * If no plugin disables the cache, the original cache is not disabled.
+   *
+   * @param source The source instance.
+   * @return The maybe disabled cache.
+   */
+  internal fun shouldDisableCache(source: NativeVideoPlayerSource): Boolean {
+    for (plugin in plugins.values) {
+      val shouldDisable = plugin.shouldDisableCache(source)
+
+      if (shouldDisable) return true
+    }
+
+    return false
+  }
+
+  /**
+   * Checks if a plugin is registered.
+   *
+   * @param plugin The plugin instance.
+   * @return True if the plugin is registered, false otherwise.
+   */
+  internal fun hasPlugin(plugin: ReactNativeVideoPluginSpec): Boolean {
+    return plugins.any { it.key == plugin.id }
+  }
+}

package/android/src/main/java/com/unifiedplayer/core/plugins/ReactNativeVideoPlugin.kt

@@ -0,0 +1,173 @@
+package com.unifiedplayer.core.plugins
+
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.exoplayer.source.MediaSource
+import com.unifiedplayer.core.player.DRMManagerSpec
+import com.unifiedplayer.view.VideoView
+import java.lang.ref.WeakReference
+
+interface ReactNativeVideoPluginSpec {
+  /**
+   * The ID of the plugin.
+   */
+  val id: String
+
+  /**
+   * The name of the plugin.
+   */
+  val name: String
+
+  /**
+   * Called when a player is created.
+   *
+   * @param player The weak reference to the player instance.
+   */
+  @UnstableApi
+  fun onPlayerCreated(player: WeakReference<NativeVideoPlayer>)
+
+  /**
+   * Called when a player is destroyed.
+   *
+   * @param player The weak reference to the player instance.
+   */
+  @UnstableApi
+  fun onPlayerDestroyed(player: WeakReference<NativeVideoPlayer>)
+
+  /**
+   * Called when a video view is created.
+   *
+   * @param view The weak reference to the video view instance.
+   */
+  @UnstableApi
+  fun onVideoViewCreated(view: WeakReference<VideoView>)
+
+  /**
+   * Called when a video view is destroyed.
+   *
+   * @param view The weak reference to the video view instance.
+   */
+  @UnstableApi
+  fun onVideoViewDestroyed(view: WeakReference<VideoView>)
+  
+  /**
+   * Called when a source is being used to create mediaItem or MediaSource.
+   * You can use it to modify the source before it is used.
+   *
+   * @param source The source instance.
+   * @return The overridden source instance.
+   */
+  fun overrideSource(source: NativeVideoPlayerSource): NativeVideoPlayerSource
+
+  /**
+   * Called when a DRM manager is requested.
+   *
+   * @return The DRM manager instance.
+   */
+  fun getDRMManager(source: NativeVideoPlayerSource): DRMManagerSpec?
+
+
+  /**
+   * Called when a media data source factory is requested.
+   *
+   * @param source The source instance.
+   * @param mediaDataSourceFactory The media data source factory.
+   * @return The media data source factory. If null is returned, the default factory will be used.
+   */
+  fun getMediaDataSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaDataSourceFactory: DataSource.Factory
+  ): DataSource.Factory?
+
+  /**
+   * Called when a media source factory is requested.
+   *
+   * @param source The source instance.
+   * @param mediaSourceFactory The media source factory.
+   * @param mediaDataSourceFactory The media data source factory.
+   * @return The media source factory. If null is returned, the default factory will be used.
+   */
+  fun getMediaSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaSourceFactory: MediaSource.Factory,
+    mediaDataSourceFactory: DataSource.Factory
+  ): MediaSource.Factory?
+
+  /**
+   * Called when a media item builder is requested.
+   *
+   * @param source The source instance.
+   * @param mediaItemBuilder The media item builder.
+   * @return The media item builder. If null is returned, the default builder will be used.
+   */
+  fun getMediaItemBuilder(
+    source: NativeVideoPlayerSource,
+    mediaItemBuilder: MediaItem.Builder
+  ): MediaItem.Builder?
+
+  /**
+   * Called when a cache should be disabled.
+   *
+   * @param source The source instance.
+   * @return True if cache should be disabled, false otherwise.
+   */
+  fun shouldDisableCache(source: NativeVideoPlayerSource): Boolean
+}
+
+@Suppress("Unused")
+/**
+ * A helper base implementation of the ReactNativeVideoPluginSpec interface.
+ */
+open class ReactNativeVideoPlugin(override val name: String) : ReactNativeVideoPluginSpec {
+  override val id = "RNV_Plugin_${name}"
+
+  init {
+    // Automatically register the plugin when it is created
+    PluginsRegistry.shared.register(this)
+  }
+
+  @UnstableApi
+  override fun onPlayerCreated(player: WeakReference<NativeVideoPlayer>) { /* NOOP */}
+
+  @UnstableApi
+  override fun onPlayerDestroyed(player: WeakReference<NativeVideoPlayer>) { /* NOOP */}
+
+  @UnstableApi
+  override fun onVideoViewCreated(view: WeakReference<VideoView>) { /* NOOP */}
+
+  @UnstableApi
+  override fun onVideoViewDestroyed(view: WeakReference<VideoView>) { /* NOOP */}
+
+  override fun overrideSource(source: NativeVideoPlayerSource): NativeVideoPlayerSource {
+    return source
+  }
+
+  override fun getDRMManager(source: NativeVideoPlayerSource): DRMManagerSpec? { return null }
+
+  override fun getMediaDataSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaDataSourceFactory: DataSource.Factory
+  ): DataSource.Factory? {
+    return null
+  }
+
+  override fun getMediaSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaSourceFactory: MediaSource.Factory,
+    mediaDataSourceFactory: DataSource.Factory
+  ): MediaSource.Factory? {
+    return null
+  }
+
+  override fun getMediaItemBuilder(
+    source: NativeVideoPlayerSource,
+    mediaItemBuilder: MediaItem.Builder
+  ): MediaItem.Builder? {
+    return null
+  }
+
+  override fun shouldDisableCache(source: NativeVideoPlayerSource): Boolean {
+    return false
+  }
+}

package/android/src/main/java/com/unifiedplayer/core/recivers/AudioBecomingNoisyReceiver.kt

@@ -0,0 +1,38 @@
+package com.unifiedplayer.core.recivers
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.media.AudioManager
+import androidx.core.content.ContextCompat
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.unifiedplayer.HybridVideoPlayerEventEmitter
+import com.unifiedplayer.core.LibraryError
+
+class AudioBecomingNoisyReceiver() : BroadcastReceiver() {
+  private var eventEmitter: HybridVideoPlayerEventEmitter? = null
+
+  override fun onReceive(context: Context?, intent: Intent?) {
+    if (intent?.action == AudioManager.ACTION_AUDIO_BECOMING_NOISY) {
+      eventEmitter?.onAudioBecomingNoisy()
+    }
+  }
+
+  fun setEventEmitter(eventEmitter: HybridVideoPlayerEventEmitter) {
+    val context = NitroModules.applicationContext ?: throw LibraryError.ApplicationContextNotFound
+
+    this.eventEmitter = eventEmitter
+    val intentFilter = IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY)
+    ContextCompat.registerReceiver(
+      context.applicationContext,
+      this,
+      intentFilter,
+      ContextCompat.RECEIVER_NOT_EXPORTED
+    )
+  }
+
+  fun removeEventEmitter() {
+    this.eventEmitter = null
+  }
+}