react-native-video-provider 0.1.1

package/AuVideo.podspec

@@ -0,0 +1,28 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "AuVideo"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/grdp99/react-native-au-video.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  s.frameworks = "AVFoundation", "AVKit"
+  s.swift_version = "5.9"
+  # Swift core + ObjC++ glue in one pod: the glue imports the generated
+  # <AuVideo/AuVideo-Swift.h>, which requires the pod to define a module.
+  s.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
+  }
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Gurdeep Singh
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,183 @@
+# react-native-video-provider
+
+**One native player. Many surfaces. Zero interruptions.**
+
+A singleton-engine video library for React Native (Android + iOS, New
+Architecture). The app owns exactly one native playback engine (ExoPlayer /
+AVPlayer) for its whole lifetime; React components are just *rendering
+surfaces* the engine attaches to. Moving from a feed cell to a detail screen
+to fullscreen to a floating window never reloads, rebuffers, or resets
+position — exactly how YouTube, Netflix and Twitter/X players behave.
+
+```
+Feed ──▶ Detail ──▶ Fullscreen (rotation unlocked) ──▶ Floating window
+              same engine · same buffer · same position
+```
+
+- 🎯 **Singleton engine** — created silently once by the provider; survives
+  navigation, tab switches, unmounts, Fast Refresh
+- 🔁 **Same-video handoff** — `setSource` with the same `id` is a no-op for
+  the engine; the player just re-parents to the new surface
+- 📺 **Fullscreen** — built-in host that unlocks rotation while visible and
+  restores the previous orientation lock on exit
+- 🎈 **Floating player** — built-in draggable in-app window
+- 🖼 **Picture in Picture** — Android + iOS
+- ⚡ **New Architecture native** — TurboModule + Fabric, typed end to end
+- 🧠 **Zustand-powered state** — selector subscriptions, no re-render storms
+
+See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the full design and
+[docs/API.md](docs/API.md) for the complete API reference.
+
+## Installation
+
+```sh
+npm install react-native-video-provider
+cd ios && pod install
+```
+
+Requires React Native 0.80+ with the New Architecture enabled.
+
+## Quick start
+
+**1. Wrap the app once.** The provider silently creates the engine and mounts
+the fullscreen/floating hosts above your app:
+
+```tsx
+import { VideoProvider } from 'react-native-video-provider';
+
+export default function App() {
+  return (
+    <VideoProvider>
+      <Navigation />
+    </VideoProvider>
+  );
+}
+```
+
+**2. Play a video anywhere:**
+
+```tsx
+import { VideoPlayer } from 'react-native-video-provider';
+
+<VideoPlayer
+  source={{ id: '123', uri: 'https://example.com/video.m3u8', title: 'Big Buck Bunny' }}
+  style={{ aspectRatio: 16 / 9 }}
+/>
+```
+
+**3. Open a detail screen with the same video** — because the `id` matches,
+the engine is untouched and playback continues from the exact frame:
+
+```tsx
+// DetailScreen.tsx — same source id ⇒ handoff, not reload
+<VideoPlayer source={{ id: '123', uri }} style={{ aspectRatio: 16 / 9 }} />
+```
+
+**4. Fullscreen / floating / PiP from anywhere:**
+
+```tsx
+const player = useVideo();
+
+player.enterFullscreen(); // rotation unlocks while visible
+player.showFloating();    // draggable in-app window
+player.enterPiP();        // system picture-in-picture
+```
+
+## Surfaces (the core idea)
+
+`<VideoSurface>` never creates a player — it registers a mount point. The
+engine renders into at most one surface at a time; `attach(id)` re-parents
+the native player view with no playback interruption. If you attach to a
+surface that hasn't mounted yet (navigation in flight), the engine attaches
+the moment it appears.
+
+```tsx
+<VideoSurface surfaceId="feed" style={{ aspectRatio: 16 / 9 }} />
+
+const player = useVideo();
+player.setSource(video);   // load (or hand off)
+player.attach('feed');     // render here
+```
+
+`<VideoPlayer>` is the convenience wrapper that does `setSource` + `attach` +
+optional controls in one component.
+
+## State & events
+
+```tsx
+// Selector subscriptions — re-render only for what you display
+const position = usePlayback((s) => s.position);
+const { isFullscreen, toggle } = useFullscreen();
+
+useVideoEvents({
+  onEnd: () => playNext(),
+  onError: (e) => console.warn(e.code, e.message),
+});
+```
+
+## Platform setup
+
+### iOS — fullscreen rotation
+
+iOS asks the AppDelegate which orientations are allowed. Forward that to the
+library so rotation unlocks only while fullscreen is visible (skip this if
+your app already supports all orientations):
+
+```swift
+// AppDelegate.swift
+import AuVideo
+
+func application(_ application: UIApplication,
+                 supportedInterfaceOrientationsFor window: UIWindow?)
+    -> UIInterfaceOrientationMask {
+  return AuVideoOrientation.mask(withDefault: .portrait)
+}
+```
+
+### iOS — Picture in Picture / background audio
+
+Enable *Audio, AirPlay and Picture in Picture* in Signing & Capabilities →
+Background Modes (adds `audio` to `UIBackgroundModes` in Info.plist).
+
+### Android — Picture in Picture
+
+Declare PiP support on your main activity in `AndroidManifest.xml`:
+
+```xml
+<activity
+  android:name=".MainActivity"
+  android:supportsPictureInPicture="true"
+  android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode|density" />
+```
+
+(The `orientation|screenSize` entries are part of the default RN template and
+also keep fullscreen rotation from recreating the activity.)
+
+## Example app
+
+```sh
+yarn
+yarn example android   # or: yarn example ios
+```
+
+The example shows a feed → detail handoff with a live status panel, plus
+fullscreen, floating and PiP buttons.
+
+## Roadmap
+
+- Queue (next/previous/playlist/autoplay)
+- Background playback (Android MediaSessionService + notification, iOS remote
+  commands / lock-screen controls)
+- Quality, subtitle and audio-track selection
+- Brightness/volume swipe gestures, pinch zoom
+- True ahead-of-time preloading (Media3 `PreloadManager`)
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) and the
+[architecture doc](docs/ARCHITECTURE.md). PRs that add a second player
+instance will be rejected on principle. 🙂
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,59 @@
+buildscript {
+  ext.AuVideo = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    media3Version: "1.8.0"
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return AuVideo[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.auvideo"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+
+  def media3Version = getExtOrDefault("media3Version")
+  implementation "androidx.media3:media3-exoplayer:${media3Version}"
+  implementation "androidx.media3:media3-exoplayer-hls:${media3Version}"
+  implementation "androidx.media3:media3-exoplayer-dash:${media3Version}"
+  implementation "androidx.media3:media3-ui:${media3Version}"
+  implementation "androidx.core:core-ktx:1.13.1"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/auvideo/AuVideoModule.kt

@@ -0,0 +1,259 @@
+package com.auvideo
+
+import android.app.PictureInPictureParams
+import android.content.pm.ActivityInfo
+import android.content.pm.PackageManager
+import android.os.Build
+import android.util.Rational
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
+
+class AuVideoModule(reactContext: ReactApplicationContext) :
+  NativeAuVideoSpec(reactContext), PlayerCore.Listener {
+
+  private var previousOrientation: Int? = null
+
+  // ------------------------------------------------------------ lifecycle
+
+  override fun nativeInit() {
+    UiThreadUtil.runOnUiThread {
+      PlayerCore.listener = this
+      PlayerCore.initialize(reactApplicationContext)
+    }
+  }
+
+  override fun releasePlayer() {
+    UiThreadUtil.runOnUiThread {
+      PlayerCore.release()
+      PlayerCore.listener = null
+    }
+  }
+
+  override fun invalidate() {
+    PlayerCore.listener = null
+    super.invalidate()
+  }
+
+  // -------------------------------------------------------------- source
+
+  override fun setSource(source: ReadableMap, autoplay: Boolean) {
+    val spec = parseSource(source) ?: return
+    UiThreadUtil.runOnUiThread { PlayerCore.setSource(spec, autoplay) }
+  }
+
+  override fun preload(source: ReadableMap) {
+    val spec = parseSource(source) ?: return
+    UiThreadUtil.runOnUiThread { PlayerCore.preload(spec) }
+  }
+
+  private fun parseSource(map: ReadableMap): SourceSpec? {
+    val id = map.getString("id") ?: return null
+    val uri = map.getString("uri") ?: return null
+    val headers = HashMap<String, String>()
+    map.getMap("headers")?.let { h ->
+      val it = h.keySetIterator()
+      while (it.hasNextKey()) {
+        val key = it.nextKey()
+        h.getString(key)?.let { value -> headers[key] = value }
+      }
+    }
+    return SourceSpec(
+      id = id,
+      uri = uri,
+      headers = headers,
+      title = map.getString("title"),
+      artist = map.getString("artist"),
+      artworkUri = map.getString("artworkUri"),
+      startPosition = if (map.hasKey("startPosition")) map.getDouble("startPosition") else 0.0,
+    )
+  }
+
+  // ------------------------------------------------------------- commands
+
+  override fun play() {
+    UiThreadUtil.runOnUiThread { PlayerCore.play() }
+  }
+
+  override fun pause() {
+    UiThreadUtil.runOnUiThread { PlayerCore.pause() }
+  }
+
+  override fun stop() {
+    UiThreadUtil.runOnUiThread { PlayerCore.stop() }
+  }
+
+  override fun seekTo(position: Double) {
+    UiThreadUtil.runOnUiThread { PlayerCore.seekTo(position) }
+  }
+
+  override fun setRate(rate: Double) {
+    UiThreadUtil.runOnUiThread { PlayerCore.setRate(rate) }
+  }
+
+  override fun setVolume(volume: Double) {
+    UiThreadUtil.runOnUiThread { PlayerCore.setVolume(volume) }
+  }
+
+  override fun setMuted(muted: Boolean) {
+    UiThreadUtil.runOnUiThread { PlayerCore.setMuted(muted) }
+  }
+
+  override fun setRepeat(repeat: Boolean) {
+    UiThreadUtil.runOnUiThread { PlayerCore.setRepeat(repeat) }
+  }
+
+  override fun setResizeMode(mode: String) {
+    UiThreadUtil.runOnUiThread { PlayerCore.setResizeMode(mode) }
+  }
+
+  override fun getPosition(promise: Promise) {
+    UiThreadUtil.runOnUiThread { promise.resolve(PlayerCore.positionSeconds()) }
+  }
+
+  // ------------------------------------------------------------- surfaces
+
+  override fun attach(surfaceId: String) {
+    UiThreadUtil.runOnUiThread { PlayerCore.attach(surfaceId) }
+  }
+
+  override fun detach() {
+    UiThreadUtil.runOnUiThread { PlayerCore.detach() }
+  }
+
+  // ----------------------------------------------------------- fullscreen
+
+  override fun enterFullscreen() {
+    UiThreadUtil.runOnUiThread {
+      val activity = currentActivity ?: return@runOnUiThread
+      if (previousOrientation == null) {
+        previousOrientation = activity.requestedOrientation
+      }
+      // Unlock rotation while fullscreen is visible, even in portrait-locked apps.
+      activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
+
+      val window = activity.window
+      WindowCompat.setDecorFitsSystemWindows(window, false)
+      WindowInsetsControllerCompat(window, window.decorView).apply {
+        systemBarsBehavior =
+          WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        hide(WindowInsetsCompat.Type.systemBars())
+      }
+    }
+  }
+
+  override fun exitFullscreen() {
+    UiThreadUtil.runOnUiThread {
+      val activity = currentActivity ?: return@runOnUiThread
+      activity.requestedOrientation =
+        previousOrientation ?: ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+      previousOrientation = null
+
+      val window = activity.window
+      WindowCompat.setDecorFitsSystemWindows(window, true)
+      WindowInsetsControllerCompat(window, window.decorView)
+        .show(WindowInsetsCompat.Type.systemBars())
+    }
+  }
+
+  // ------------------------------------------------------------------ pip
+
+  override fun enterPip(promise: Promise) {
+    UiThreadUtil.runOnUiThread {
+      val activity = currentActivity
+      if (
+        activity == null ||
+        Build.VERSION.SDK_INT < Build.VERSION_CODES.O ||
+        !activity.packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)
+      ) {
+        promise.resolve(false)
+        return@runOnUiThread
+      }
+      try {
+        val params = PictureInPictureParams.Builder()
+          .setAspectRatio(Rational(16, 9))
+          .build()
+        val entered = activity.enterPictureInPictureMode(params)
+        if (entered) {
+          emitOnPipChange(Arguments.createMap().apply { putBoolean("active", true) })
+        }
+        promise.resolve(entered)
+      } catch (e: Exception) {
+        promise.resolve(false)
+      }
+    }
+  }
+
+  override fun exitPip() {
+    UiThreadUtil.runOnUiThread {
+      // Android has no direct "leave PiP" API; bringing the task forward
+      // expands the PiP window back into the full activity.
+      val activity = currentActivity ?: return@runOnUiThread
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && activity.isInPictureInPictureMode) {
+        activity.moveTaskToBack(false)
+        emitOnPipChange(Arguments.createMap().apply { putBoolean("active", false) })
+      }
+    }
+  }
+
+  // --------------------------------------------------- PlayerCore.Listener
+
+  override fun onStatusChange(status: String) {
+    emitOnStatusChange(Arguments.createMap().apply { putString("status", status) })
+  }
+
+  override fun onLoad(videoId: String, duration: Double, width: Int, height: Int) {
+    emitOnLoad(
+      Arguments.createMap().apply {
+        putString("videoId", videoId)
+        putDouble("duration", duration)
+        putDouble("width", width.toDouble())
+        putDouble("height", height.toDouble())
+      }
+    )
+  }
+
+  override fun onProgress(position: Double, duration: Double, buffered: Double) {
+    emitOnProgress(
+      Arguments.createMap().apply {
+        putDouble("position", position)
+        putDouble("duration", duration)
+        putDouble("buffered", buffered)
+      }
+    )
+  }
+
+  override fun onSeek(position: Double) {
+    emitOnSeek(Arguments.createMap().apply { putDouble("position", position) })
+  }
+
+  override fun onEnd() {
+    emitOnEnd()
+  }
+
+  override fun onError(code: String, message: String) {
+    emitOnError(
+      Arguments.createMap().apply {
+        putString("code", code)
+        putString("message", message)
+      }
+    )
+  }
+
+  override fun onAttach(surfaceId: String) {
+    emitOnAttach(Arguments.createMap().apply { putString("surfaceId", surfaceId) })
+  }
+
+  override fun onDetach(surfaceId: String) {
+    emitOnDetach(Arguments.createMap().apply { putString("surfaceId", surfaceId) })
+  }
+
+  companion object {
+    const val NAME = NativeAuVideoSpec.NAME
+  }
+}

package/android/src/main/java/com/auvideo/AuVideoPackage.kt

@@ -0,0 +1,35 @@
+package com.auvideo
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+class AuVideoPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == AuVideoModule.NAME) {
+      AuVideoModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext
+  ): List<ViewManager<*, *>> = listOf(AuVideoSurfaceViewManager())
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      AuVideoModule.NAME to ReactModuleInfo(
+        name = AuVideoModule.NAME,
+        className = AuVideoModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+    )
+  }
+}

package/android/src/main/java/com/auvideo/AuVideoSurfaceView.kt

@@ -0,0 +1,40 @@
+package com.auvideo
+
+import android.content.Context
+import android.view.View
+import android.widget.FrameLayout
+
+/**
+ * A dumb mount point the player view gets re-parented into. Does not create
+ * or own any player resources.
+ */
+class AuVideoSurfaceView(context: Context) : FrameLayout(context) {
+
+  var surfaceId: String? = null
+    set(value) {
+      if (field == value) return
+      field?.let { SurfaceRegistry.unregister(it, this) }
+      field = value
+      value?.let { SurfaceRegistry.register(it, this) }
+    }
+
+  // RN lays this view out itself; children added natively (the player view)
+  // would otherwise never get measured. Standard measure-and-layout relay.
+  private val measureAndLayout = Runnable {
+    measure(
+      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+    )
+    layout(left, top, right, bottom)
+  }
+
+  override fun requestLayout() {
+    super.requestLayout()
+    post(measureAndLayout)
+  }
+
+  override fun onViewAdded(child: View?) {
+    super.onViewAdded(child)
+    post(measureAndLayout)
+  }
+}

package/android/src/main/java/com/auvideo/AuVideoSurfaceViewManager.kt

@@ -0,0 +1,38 @@
+package com.auvideo
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.AuVideoSurfaceViewManagerDelegate
+import com.facebook.react.viewmanagers.AuVideoSurfaceViewManagerInterface
+
+@ReactModule(name = AuVideoSurfaceViewManager.NAME)
+class AuVideoSurfaceViewManager :
+  SimpleViewManager<AuVideoSurfaceView>(),
+  AuVideoSurfaceViewManagerInterface<AuVideoSurfaceView> {
+
+  private val delegate = AuVideoSurfaceViewManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<AuVideoSurfaceView> = delegate
+
+  override fun getName(): String = NAME
+
+  override fun createViewInstance(context: ThemedReactContext): AuVideoSurfaceView =
+    AuVideoSurfaceView(context)
+
+  @ReactProp(name = "surfaceId")
+  override fun setSurfaceId(view: AuVideoSurfaceView, value: String?) {
+    view.surfaceId = value
+  }
+
+  override fun onDropViewInstance(view: AuVideoSurfaceView) {
+    view.surfaceId = null
+    super.onDropViewInstance(view)
+  }
+
+  companion object {
+    const val NAME = "AuVideoSurfaceView"
+  }
+}