spactureai-mobile-player 1.0.30

package/android/src/main/java/com/unifiedplayer/hybrids/videoplayer/HybridVideoPlayerFactory.kt

@@ -0,0 +1,16 @@
+package com.margelo.nitro.unifiedplayer
+
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import com.facebook.proguard.annotations.DoNotStrip
+
+@DoNotStrip
+class HybridVideoPlayerFactory(): HybridVideoPlayerFactorySpec() {
+  @OptIn(UnstableApi::class)
+  override fun createPlayer(source: HybridVideoPlayerSourceSpec): HybridVideoPlayerSpec {
+    return HybridVideoPlayer(source as HybridVideoPlayerSource)
+  }
+
+  override val memorySize: Long
+    get() = 0
+}

package/android/src/main/java/com/unifiedplayer/hybrids/videoplayereventemitter/HybridVideoPlayerEventEmitter.kt

@@ -0,0 +1,180 @@
+package com.margelo.nitro.unifiedplayer
+
+import android.util.Log
+import com.margelo.nitro.core.NullType
+import java.util.UUID
+
+data class ListenerPair(val id: UUID, val eventName: String, val callback: Any)
+
+class HybridVideoPlayerEventEmitter : HybridVideoPlayerEventEmitterSpec() {
+  private val lock = Any()
+
+  var listeners: MutableList<ListenerPair> = mutableListOf()
+
+  // MARK: - Private helpers
+  private fun <T : Any> addListener(eventName: String, listener: T): ListenerSubscription {
+    val id = UUID.randomUUID()
+    synchronized(lock) {
+      listeners.add(ListenerPair(id, eventName, listener))
+    }
+    return ListenerSubscription {
+      synchronized(lock) {
+        listeners.removeAll { it.id == id }
+      }
+    }
+  }
+
+  private inline fun <reified T> emitEvent(eventName: String, invokeCallback: (T) -> Unit) {
+    val snapshot: List<ListenerPair> = synchronized(lock) {
+      listeners.filter { it.eventName == eventName }.toList()
+    }
+
+    snapshot.forEach { pair ->
+      try {
+        @Suppress("UNCHECKED_CAST")
+        val callback = pair.callback as? T ?: run {
+          Log.d(TAG, "Invalid callback type for $eventName")
+          return@forEach
+        }
+        invokeCallback(callback)
+      } catch (t: Throwable) {
+        Log.d(TAG, "Error calling $eventName listener", t)
+      }
+    }
+  }
+
+
+  // MARK: - Listener registration methods
+  
+  override fun addOnAudioBecomingNoisyListener(listener: () -> Unit) =
+    addListener("onAudioBecomingNoisy", listener)
+
+  override fun addOnAudioFocusChangeListener(listener: (Boolean) -> Unit) =
+    addListener("onAudioFocusChange", listener)
+
+  override fun addOnBandwidthUpdateListener(listener: (BandwidthData) -> Unit) =
+    addListener("onBandwidthUpdate", listener)
+
+  override fun addOnBufferListener(listener: (Boolean) -> Unit) =
+    addListener("onBuffer", listener)
+
+  override fun addOnControlsVisibleChangeListener(listener: (Boolean) -> Unit) =
+    addListener("onControlsVisibleChange", listener)
+
+  override fun addOnEndListener(listener: () -> Unit) =
+    addListener("onEnd", listener)
+
+  override fun addOnExternalPlaybackChangeListener(listener: (Boolean) -> Unit) =
+    addListener("onExternalPlaybackChange", listener)
+
+  override fun addOnLoadListener(listener: (onLoadData) -> Unit) =
+    addListener("onLoad", listener)
+
+  override fun addOnLoadStartListener(listener: (onLoadStartData) -> Unit) =
+    addListener("onLoadStart", listener)
+
+  override fun addOnPlaybackStateChangeListener(listener: (onPlaybackStateChangeData) -> Unit) =
+    addListener("onPlaybackStateChange", listener)
+
+  override fun addOnPlaybackRateChangeListener(listener: (Double) -> Unit) =
+    addListener("onPlaybackRateChange", listener)
+
+  override fun addOnProgressListener(listener: (onProgressData) -> Unit) =
+    addListener("onProgress", listener)
+
+  override fun addOnReadyToDisplayListener(listener: () -> Unit) =
+    addListener("onReadyToDisplay", listener)
+
+  override fun addOnSeekListener(listener: (Double) -> Unit) =
+    addListener("onSeek", listener)
+
+  override fun addOnStatusChangeListener(listener: (VideoPlayerStatus) -> Unit) =
+    addListener("onStatusChange", listener)
+
+  override fun addOnTimedMetadataListener(listener: (TimedMetadata) -> Unit) =
+    addListener("onTimedMetadata", listener)
+
+  override fun addOnTextTrackDataChangedListener(listener: (Array<String>) -> Unit) =
+    addListener("onTextTrackDataChanged", listener)
+
+  override fun addOnTrackChangeListener(listener: (Variant_NullType_TextTrack?) -> Unit) =
+    addListener("onTrackChange", listener)
+
+  override fun addOnVolumeChangeListener(listener: (onVolumeChangeData) -> Unit) =
+    addListener("onVolumeChange", listener)
+
+  override fun clearAllListeners() {
+    synchronized(lock) {
+      listeners.clear()
+    }
+  }
+
+  // MARK: - Event emission methods
+
+  fun onAudioBecomingNoisy() =
+    emitEvent<() -> Unit>("onAudioBecomingNoisy") { it() }
+
+  fun onAudioFocusChange(hasFocus: Boolean) =
+    emitEvent<(Boolean) -> Unit>("onAudioFocusChange") { it(hasFocus) }
+
+  fun onBandwidthUpdate(data: BandwidthData) =
+    emitEvent<(BandwidthData) -> Unit>("onBandwidthUpdate") { it(data) }
+
+  fun onBuffer(isBuffering: Boolean) =
+    emitEvent<(Boolean) -> Unit>("onBuffer") { it(isBuffering) }
+
+  fun onControlsVisibleChange(isVisible: Boolean) =
+    emitEvent<(Boolean) -> Unit>("onControlsVisibleChange") { it(isVisible) }
+
+  fun onEnd() =
+    emitEvent<() -> Unit>("onEnd") { it() }
+
+  fun onExternalPlaybackChange(isExternalPlayback: Boolean) =
+    emitEvent<(Boolean) -> Unit>("onExternalPlaybackChange") { it(isExternalPlayback) }
+
+  fun onLoad(data: onLoadData) =
+    emitEvent<(onLoadData) -> Unit>("onLoad") { it(data) }
+
+  fun onLoadStart(data: onLoadStartData) =
+    emitEvent<(onLoadStartData) -> Unit>("onLoadStart") { it(data) }
+
+  fun onPlaybackStateChange(data: onPlaybackStateChangeData) =
+    emitEvent<(onPlaybackStateChangeData) -> Unit>("onPlaybackStateChange") { it(data) }
+
+  fun onPlaybackRateChange(rate: Double) =
+    emitEvent<(Double) -> Unit>("onPlaybackRateChange") { it(rate) }
+
+  fun onProgress(data: onProgressData) =
+    emitEvent<(onProgressData) -> Unit>("onProgress") { it(data) }
+
+  fun onReadyToDisplay() =
+    emitEvent<() -> Unit>("onReadyToDisplay") { it() }
+
+  fun onSeek(position: Double) =
+    emitEvent<(Double) -> Unit>("onSeek") { it(position) }
+
+  fun onTimedMetadata(metadata: TimedMetadata) =
+    emitEvent<(TimedMetadata) -> Unit>("onTimedMetadata") { it(metadata) }
+
+  fun onTextTrackDataChanged(tracks: Array<String>) =
+    emitEvent<(Array<String>) -> Unit>("onTextTrackDataChanged") { it(tracks) }
+
+  fun onTrackChange(track: TextTrack?) {
+    val param = if (track == null) {
+      Variant_NullType_TextTrack.create(NullType.NULL)
+    } else {
+      Variant_NullType_TextTrack.create(track)
+    }
+    emitEvent<(Variant_NullType_TextTrack?) -> Unit>("onTrackChange") { it(param) }
+  }
+
+  fun onVolumeChange(data: onVolumeChangeData) =
+    emitEvent<(onVolumeChangeData) -> Unit>("onVolumeChange") { it(data) }
+
+  fun onStatusChange(status: VideoPlayerStatus) =
+    emitEvent<(VideoPlayerStatus) -> Unit>("onStatusChange") { it(status) }
+
+  companion object {
+    const val TAG = "HybridVideoPlayerEventEmitter"
+  }
+}

package/android/src/main/java/com/unifiedplayer/hybrids/videoplayersource/HybridVideoPlayerSource.kt

@@ -0,0 +1,67 @@
+package com.margelo.nitro.unifiedplayer
+
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.drm.DrmSessionManager
+import androidx.media3.exoplayer.source.MediaSource
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import com.unifiedplayer.core.LibraryError
+import com.unifiedplayer.core.player.DRMManagerSpec
+import com.unifiedplayer.core.player.buildMediaSource
+import com.unifiedplayer.core.player.createMediaItemFromVideoConfig
+import com.unifiedplayer.core.plugins.PluginsRegistry
+import com.unifiedplayer.core.utils.SourceLoader
+import com.unifiedplayer.core.utils.VideoInformationUtils
+
+class HybridVideoPlayerSource(): HybridVideoPlayerSourceSpec() {
+  override lateinit var uri: String
+  override lateinit var config: NativeVideoConfig
+
+  private lateinit var mediaItem: MediaItem
+  lateinit var mediaSource: MediaSource
+
+  var drmManager: DRMManagerSpec? = null
+
+  @UnstableApi
+  var drmSessionManager: DrmSessionManager? = null
+
+  internal val sourceLoader = SourceLoader()
+
+  constructor(config: NativeVideoConfig) : this() {
+    this.uri = config.uri
+    this.config = config
+
+    val overriddenSource = PluginsRegistry.shared.overrideSource(this)
+
+    config.drm?.let {
+      drmManager = PluginsRegistry.shared.getDRMManager(this)
+      drmSessionManager = drmManager?.buildDrmSessionManager(it)
+    }
+
+    this.mediaItem = createMediaItemFromVideoConfig(
+      overriddenSource
+    )
+
+    NitroModules.applicationContext?.let {
+      this.mediaSource = buildMediaSource(
+        context = it,
+        source = overriddenSource,
+        mediaItem
+      )
+    } ?: run {
+      throw LibraryError.ApplicationContextNotFound
+    }
+  }
+
+  override fun getAssetInformationAsync(): Promise<VideoInformation> {
+    return Promise.async {
+      return@async sourceLoader.load {
+        VideoInformationUtils.fromUri(uri, config.headers ?: emptyMap())
+      }
+    }
+  }
+
+  override val memorySize: Long
+    get() = 0
+}

package/android/src/main/java/com/unifiedplayer/hybrids/videoplayersource/HybridVideoPlayerSourceFactory.kt

@@ -0,0 +1,58 @@
+package com.margelo.nitro.unifiedplayer
+
+import android.content.Context
+import android.net.Uri
+import androidx.media3.common.MediaItem
+import androidx.media3.datasource.RawResourceDataSource
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+
+@DoNotStrip
+class HybridVideoPlayerSourceFactory: HybridVideoPlayerSourceFactorySpec() {
+  private val applicationContext: Context
+    get() = NitroModules.applicationContext
+      ?: throw IllegalStateException(
+        "NitroModules.applicationContext has not been initialized."
+      )
+
+  private fun normalizeUri(input: String): String {
+    val parsedUri = Uri.parse(input)
+
+    if (parsedUri.scheme != null) {
+      return parsedUri.toString()
+    }
+
+    val resId = applicationContext.resources
+      .getIdentifier(input, "raw", applicationContext.packageName)
+
+    if (resId == 0) {
+      throw IllegalArgumentException("The video resource '$input' could not be found in res/raw")
+    }
+
+    val mediaUri = RawResourceDataSource.buildRawResourceUri(resId)
+
+    return mediaUri.toString()
+  }
+
+  override fun fromUri(uri: String): HybridVideoPlayerSourceSpec {
+    val config = NativeVideoConfig(
+      uri = normalizeUri(uri),
+      externalSubtitles = null,
+      drm = null,
+      headers = null,
+      bufferConfig = null,
+      metadata = null,
+      initializeOnCreation = true
+    )
+
+    return HybridVideoPlayerSource(config)
+  }
+
+  override fun fromVideoConfig(config: NativeVideoConfig): HybridVideoPlayerSourceSpec {
+    return HybridVideoPlayerSource(config)
+  }
+
+  override val memorySize: Long
+    get() = 0
+}

package/android/src/main/java/com/unifiedplayer/hybrids/videoviewviewmanager/HybridVideoViewViewManager.kt

@@ -0,0 +1,187 @@
+package com.margelo.nitro.unifiedplayer
+
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import com.facebook.proguard.annotations.DoNotStrip
+import com.unifiedplayer.core.VideoManager
+import com.unifiedplayer.core.VideoViewError
+import com.unifiedplayer.core.utils.PictureInPictureUtils
+import com.unifiedplayer.core.utils.Threading
+import java.util.UUID
+
+data class ViewListenerPair(
+  val id: UUID,
+  val eventName: String,
+  val callback: Any
+)
+
+@DoNotStrip
+@OptIn(UnstableApi::class)
+class HybridVideoViewViewManager(nitroId: Int): HybridVideoViewViewManagerSpec(), VideoViewEventsEmitter {
+  private var videoView =
+    VideoManager.getVideoViewWeakReferenceByNitroId(nitroId) ?: throw VideoViewError.ViewNotFound(nitroId)
+  private val listeners = mutableListOf<ViewListenerPair>()
+
+  init {
+    videoView.get()?.eventsEmitter = this
+  }
+
+  override var player: HybridVideoPlayerSpec?
+    get() {
+      return Threading.runOnMainThreadSync { return@runOnMainThreadSync videoView.get()?.hybridPlayer }
+    }
+    set(value) {
+      Threading.runOnMainThread {
+        videoView.get()?.hybridPlayer = value as? HybridVideoPlayer
+      }
+    }
+
+  override fun canEnterPictureInPicture(): Boolean {
+    return PictureInPictureUtils.canEnterPictureInPicture()
+  }
+
+  override fun enterFullscreen() {
+    videoView.get()?.enterFullscreen()
+  }
+
+  override fun exitFullscreen() {
+    videoView.get()?.exitFullscreen()
+  }
+
+  override fun enterPictureInPicture() {
+    Threading.runOnMainThread {
+      videoView.get()?.enterPictureInPicture()
+    }
+  }
+
+  override fun exitPictureInPicture() {
+    Threading.runOnMainThread {
+      videoView.get()?.exitPictureInPicture()
+    }
+  }
+
+  override var autoEnterPictureInPicture: Boolean
+    get() = videoView.get()?.autoEnterPictureInPicture == true
+    set(value) {
+      Threading.runOnMainThread {
+        videoView.get()?.autoEnterPictureInPicture = value
+      }
+    }
+
+  override var pictureInPicture: Boolean
+    get() = videoView.get()?.pictureInPictureEnabled == true
+    set(value) {
+      videoView.get()?.pictureInPictureEnabled = value
+    }
+
+  override var controls: Boolean
+    get() = videoView.get()?.useController == true
+    set(value) {
+      videoView.get()?.useController = value
+    }
+
+  override var resizeMode: ResizeMode
+    get() = videoView.get()?.resizeMode ?: ResizeMode.NONE
+    set(value) {
+      videoView.get()?.resizeMode = value
+    }
+
+  override var keepScreenAwake: Boolean
+    get() = videoView.get()?.keepScreenAwake == true
+    set(value) {
+      videoView.get()?.keepScreenAwake = value
+    }
+
+  override var surfaceType: SurfaceType
+    get() = videoView.get()?.surfaceType ?: SurfaceType.SURFACE
+    set(value) {
+      videoView.get()?.surfaceType = value
+    }
+
+  // MARK: - Private helpers
+
+  private fun <T> addListener(eventName: String, listener: T): ListenerSubscription {
+    val id = UUID.randomUUID()
+    listeners.add(ViewListenerPair(id, eventName, listener as Any))
+    return ListenerSubscription { listeners.removeAll { it.id == id } }
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  private fun <T> emitEvent(eventName: String, invoke: (T) -> Unit) {
+    listeners.filter { it.eventName == eventName }.forEach { pair ->
+      try {
+        invoke(pair.callback as T)
+      } catch (e: Exception) {
+        println("[UnifiedPlayer] Error calling $eventName listener: $e")
+      }
+    }
+  }
+
+  // MARK: - Listener registration methods
+
+  override fun addOnPictureInPictureChangeListener(listener: (Boolean) -> Unit): ListenerSubscription {
+    return addListener("onPictureInPictureChange", listener)
+  }
+
+  override fun addOnFullscreenChangeListener(listener: (Boolean) -> Unit): ListenerSubscription {
+    return addListener("onFullscreenChange", listener)
+  }
+
+  override fun addWillEnterFullscreenListener(listener: () -> Unit): ListenerSubscription {
+    return addListener("willEnterFullscreen", listener)
+  }
+
+  override fun addWillExitFullscreenListener(listener: () -> Unit): ListenerSubscription {
+    return addListener("willExitFullscreen", listener)
+  }
+
+  override fun addWillEnterPictureInPictureListener(listener: () -> Unit): ListenerSubscription {
+    return addListener("willEnterPictureInPicture", listener)
+  }
+
+  override fun addWillExitPictureInPictureListener(listener: () -> Unit): ListenerSubscription {
+    return addListener("willExitPictureInPicture", listener)
+  }
+
+  override fun clearAllListeners() {
+    listeners.clear()
+  }
+
+  // MARK: - Event emission methods (called by VideoView)
+
+  override fun onPictureInPictureChange(isActive: Boolean) {
+    emitEvent<(Boolean) -> Unit>("onPictureInPictureChange") { it(isActive) }
+  }
+
+  override fun onFullscreenChange(isActive: Boolean) {
+    emitEvent<(Boolean) -> Unit>("onFullscreenChange") { it(isActive) }
+  }
+
+  override fun willEnterFullscreen() {
+    emitEvent<() -> Unit>("willEnterFullscreen") { it() }
+  }
+
+  override fun willExitFullscreen() {
+    emitEvent<() -> Unit>("willExitFullscreen") { it() }
+  }
+
+  override fun willEnterPictureInPicture() {
+    emitEvent<() -> Unit>("willEnterPictureInPicture") { it() }
+  }
+
+  override fun willExitPictureInPicture() {
+    emitEvent<() -> Unit>("willExitPictureInPicture") { it() }
+  }
+
+  override val memorySize: Long
+    get() = 0
+}
+
+interface VideoViewEventsEmitter {
+  fun onPictureInPictureChange(isActive: Boolean)
+  fun onFullscreenChange(isActive: Boolean)
+  fun willEnterFullscreen()
+  fun willExitFullscreen()
+  fun willEnterPictureInPicture()
+  fun willExitPictureInPicture()
+}

package/android/src/main/java/com/unifiedplayer/hybrids/videoviewviewmanager/HybridVideoViewViewManagerFactory.kt

@@ -0,0 +1,13 @@
+package com.margelo.nitro.unifiedplayer
+
+import com.facebook.proguard.annotations.DoNotStrip
+
+@DoNotStrip
+class HybridVideoViewViewManagerFactory: HybridVideoViewViewManagerFactorySpec() {
+  override fun createViewManager(nitroId: Double): HybridVideoViewViewManagerSpec {
+    return HybridVideoViewViewManager(nitroId.toInt())
+  }
+
+  override val memorySize: Long
+    get() = 0
+}

package/android/src/main/java/com/unifiedplayer/react/VideoPackage.kt

@@ -0,0 +1,25 @@
+package com.unifiedplayer.react
+
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class VideoPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return emptyList()
+  }
+
+  @OptIn(UnstableApi::class)
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return listOf(VideoViewViewManager())
+  }
+
+  companion object {
+    init {
+      System.loadLibrary("UnifiedPlayer")
+    }
+  }
+}

package/android/src/main/java/com/unifiedplayer/react/VideoViewViewManager.kt

@@ -0,0 +1,78 @@
+package com.unifiedplayer.react
+
+import androidx.media3.common.util.UnstableApi
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.viewmanagers.RNCVideoViewManagerDelegate
+import com.facebook.react.viewmanagers.RNCVideoViewManagerInterface
+import com.unifiedplayer.view.VideoView
+
+internal class NitroIdChange(
+  surfaceId: Int,
+  viewTag: Int,
+  val nitroId: Int
+) : Event<NitroIdChange>(surfaceId, viewTag) {
+  override fun getEventName() = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap().apply {
+    putInt("nitroId", nitroId)
+  }
+
+  companion object {
+    const val EVENT_NAME = "topNitroIdChange"
+  }
+}
+
+@UnstableApi
+@ReactModule(name = VideoViewViewManager.NAME)
+class VideoViewViewManager : SimpleViewManager<VideoView>(), RNCVideoViewManagerInterface<VideoView> {
+  private val mDelegate: ViewManagerDelegate<VideoView>
+
+  init {
+    mDelegate = RNCVideoViewManagerDelegate(this)
+  }
+
+  @ReactProp(name = "nitroId")
+  override fun setNitroId(view: VideoView, nitroId: Int) {
+    view.nitroId = nitroId
+  }
+
+  public override fun createViewInstance(reactContext: ThemedReactContext): VideoView {
+    return VideoView(reactContext)
+  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> {
+    return MapBuilder.builder<String, Any>()
+      .put(NitroIdChange.EVENT_NAME, MapBuilder.of("registrationName", "onNitroIdChange"))
+      .build()
+  }
+
+  override fun getName() = NAME
+
+  override fun getDelegate() = mDelegate
+
+  override fun addEventEmitters(reactContext: ThemedReactContext, view: VideoView) {
+    super.addEventEmitters(reactContext, view)
+
+    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id)
+
+    if (dispatcher != null) {
+      view.onNitroIdChange = {
+        dispatcher.dispatchEvent(NitroIdChange(surfaceId, view.id, view.nitroId))
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = "RNCVideoView"
+  }
+}