react-native-video-provider 0.2.0 → 0.2.2

package/src/core/VideoManager.ts

@@ -25,6 +25,14 @@ export const FLOATING_SURFACE_ID = '__au_floating__';
 
 const RESERVED_SURFACES = new Set([FULLSCREEN_SURFACE_ID, FLOATING_SURFACE_ID]);
 
+const ORIENTATION_LOCKS: readonly OrientationLock[] = [
+  'auto',
+  'portrait',
+  'inverted-portrait',
+  'landscape',
+  'inverted-landscape',
+];
+
 function toNativeSource(source: VideoSource): NativeVideoSource {
   return {
     id: source.id,
@@ -63,11 +71,13 @@ export class VideoManager {
     fullscreenHost: true,
     floatingHost: true,
     pauseOnDetach: false,
-    fullscreenOrientation: 'auto',
   };
   /** Last non-reserved surface, restored after fullscreen/floating exits. */
   private lastInlineSurfaceId: string | null = null;
 
+  /** Per-player default for `enterFullscreen()` (VideoPlayer's prop). */
+  private fullscreenOrientationDefault: OrientationLock | null = null;
+
   private constructor() {}
 
   get providerConfig(): Required<VideoProviderConfig> {
@@ -306,6 +316,17 @@ export class VideoManager {
     NativeAuVideo.setOrientation(lock);
   }
 
+  /**
+   * Register the orientation `enterFullscreen()` uses when called without an
+   * argument (the built-in controls call it that way). Scoped: applied when
+   * fullscreen opens, restored when it closes — the rest of the app is
+   * unaffected. Pass null to unregister. Set by VideoPlayer's
+   * `fullscreenOrientation` prop.
+   */
+  setFullscreenOrientation(lock: OrientationLock | null): void {
+    this.fullscreenOrientationDefault = lock;
+  }
+
   async getPosition(): Promise<number> {
     return NativeAuVideo.getPosition();
   }
@@ -350,43 +371,55 @@ export class VideoManager {
   // ------------------------------------------------------------ modes
 
   /**
-   * Show the built-in fullscreen host and unlock device rotation.
-   * The host mounts a surface and attaches automatically.
+   * Show the built-in fullscreen host. Rotation unlocks by default; pass an
+   * orientation (or set VideoPlayer's `fullscreenOrientation` prop) to force
+   * one for the fullscreen session only. That scoped orientation is the
+   * highest priority — it's applied in the SAME native call as entering
+   * fullscreen (never as a separate follow-up call), so there is no
+   * unlocked frame where the sensor could win before the lock takes effect.
+   * Restored on exit; the rest of the app never sees the lock.
    */
-  enterFullscreen(): void {
+  enterFullscreen(orientation?: OrientationLock): void {
     if (this.store.getState().fullscreen) {
       return;
     }
     this.set({ fullscreen: true, floating: false });
     this.setMode('fullscreen');
-    NativeAuVideo.enterFullscreen();
-    const forced = this.config.fullscreenOrientation;
-    if (forced !== 'auto') {
-      NativeAuVideo.setOrientation(forced);
-    }
+    // `enter` is often passed straight to onPress, so the argument may be a
+    // press event — only honor real orientation values.
+    const requested = ORIENTATION_LOCKS.includes(orientation as OrientationLock)
+      ? (orientation as OrientationLock)
+      : this.fullscreenOrientationDefault;
+    // A scoped override wins outright; otherwise carry any standing
+    // setOrientation() lock through fullscreen unchanged (still higher
+    // priority than the sensor unlock — 'auto' just means neither applies).
+    const lock =
+      requested && requested !== 'auto'
+        ? requested
+        : this.store.getState().orientationLock;
+    NativeAuVideo.enterFullscreen(lock);
     this.events.emit('onEnterFullscreen', undefined);
   }
 
-  /** Restore the previous orientation lock and re-attach the previous surface. */
+  /** Restore the standing orientation lock (if any) and re-attach the previous surface. */
   exitFullscreen(): void {
     if (!this.store.getState().fullscreen) {
       return;
     }
-    if (this.config.fullscreenOrientation !== 'auto') {
-      // Drop the fullscreen-only lock, restoring any explicit setOrientation.
-      NativeAuVideo.setOrientation(this.store.getState().orientationLock);
-    }
-    NativeAuVideo.exitFullscreen();
+    // Always restore the standing lock (or 'auto' if none) — a
+    // fullscreen-scoped override was never written to state, so this
+    // naturally drops it without needing to track whether one was applied.
+    NativeAuVideo.exitFullscreen(this.store.getState().orientationLock);
     this.set({ fullscreen: false });
     this.events.emit('onExitFullscreen', undefined);
     this.restoreInlineSurface();
   }
 
-  toggleFullscreen(): void {
+  toggleFullscreen(orientation?: OrientationLock): void {
     if (this.store.getState().fullscreen) {
       this.exitFullscreen();
     } else {
-      this.enterFullscreen();
+      this.enterFullscreen(orientation);
     }
   }
 
@@ -450,6 +483,7 @@ export class VideoManager {
     this.events.removeAll();
     this.initialized = false;
     this.lastInlineSurfaceId = null;
+    this.fullscreenOrientationDefault = null;
     NativeAuVideo.setOrientation('auto');
     NativeAuVideo.releasePlayer();
     this.store.setState({ ...initialVideoState }, true);

package/src/hooks/useFullscreen.ts

@@ -8,9 +8,15 @@ export function useFullscreen() {
   const isFullscreen = usePlayback((s) => s.fullscreen);
   const orientationLock = usePlayback((s) => s.orientationLock);
 
-  const enter = useCallback(() => manager.enterFullscreen(), [manager]);
+  const enter = useCallback(
+    (orientation?: OrientationLock) => manager.enterFullscreen(orientation),
+    [manager]
+  );
   const exit = useCallback(() => manager.exitFullscreen(), [manager]);
-  const toggle = useCallback(() => manager.toggleFullscreen(), [manager]);
+  const toggle = useCallback(
+    (orientation?: OrientationLock) => manager.toggleFullscreen(orientation),
+    [manager]
+  );
   const setOrientation = useCallback(
     (lock: OrientationLock) => manager.setOrientation(lock),
     [manager]

package/src/types/video.ts

@@ -100,10 +100,4 @@ export interface VideoProviderConfig {
   floatingHost?: boolean;
   /** Pause playback when the active surface unmounts. Default false. */
   pauseOnDetach?: boolean;
-  /**
-   * Orientation to force while fullscreen is active, e.g. `'landscape'`.
-   * Restored to the previous lock (or `'auto'`) on exit.
-   * Default `'auto'` — fullscreen just unlocks the sensor.
-   */
-  fullscreenOrientation?: OrientationLock;
 }