@stepincto/expo-video 1.0.4 → 1.0.6

package/ios/Records/FullscreenOptions.swift

@@ -0,0 +1,12 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+internal struct FullscreenOptions: Record {
+  @Field
+  var enable: Bool = true
+  @Field
+  var orientation: FullscreenOrientation = FullscreenOrientation.default
+  @Field
+  var autoExitOnRotate: Bool = false
+}

package/ios/VideoAsset.swift

@@ -72,8 +72,11 @@ internal class VideoAsset: AVURLAsset, @unchecked Sendable {
     guard useCaching else {
       return
     }
-    if let saveFilePath, let cachedFileUrl = URL(string: saveFilePath) {
+    if let saveFilePath {
+      // Use fileURLWithPath for proper file URL creation instead of URL(string:)
+      let cachedFileUrl = URL(fileURLWithPath: saveFilePath)
       VideoCacheManager.shared.unregisterOpenFile(at: cachedFileUrl)
+      print("[VideoAsset] Unregistering file URL: \(cachedFileUrl.path)")
     }
     VideoCacheManager.shared.ensureCacheSize()
   }

package/ios/VideoModule.swift

@@ -85,6 +85,14 @@ public final class VideoModule: Module {
         )
       }
 
+      Prop("fullscreenOptions") { (view, options: FullscreenOptions?) in
+        #if !os(tvOS)
+        view.playerViewController.fullscreenOrientation = options?.orientation.toUIInterfaceOrientationMask() ?? .all
+        view.playerViewController.autoExitOnRotate = options?.autoExitOnRotate ?? false
+        view.playerViewController.setValue(options?.enable ?? true, forKey: "allowsEnteringFullScreen")
+        #endif
+      }
+
       Prop("allowsFullscreen") { (view, allowsFullscreen: Bool?) in
         #if !os(tvOS)
         view.playerViewController.setValue(allowsFullscreen ?? true, forKey: "allowsEnteringFullScreen")

package/ios/VideoView.swift

@@ -4,7 +4,7 @@ import AVKit
 import ExpoModulesCore
 
 public final class VideoView: ExpoView, AVPlayerViewControllerDelegate {
-  lazy var playerViewController = AVPlayerViewController()
+  lazy var playerViewController = OrientationAVPlayerViewController(delegate: self)
 
   weak var player: VideoPlayer? {
     didSet {
@@ -14,11 +14,8 @@ public final class VideoView: ExpoView, AVPlayerViewControllerDelegate {
 
   #if os(tvOS)
   var wasPlaying: Bool = false
-  #endif
-  var isFullscreen: Bool = false
-  var isInPictureInPicture = false
-  #if os(tvOS)
   let startPictureInPictureAutomatically = false
+  var isFullscreen: Bool = false
   #else
   var startPictureInPictureAutomatically = false {
     didSet {
@@ -55,7 +52,6 @@ public final class VideoView: ExpoView, AVPlayerViewControllerDelegate {
     VideoManager.shared.register(videoView: self)
 
     clipsToBounds = true
-    playerViewController.delegate = self
     playerViewController.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
     playerViewController.view.backgroundColor = .clear
     // Now playing is managed by the `NowPlayingManager`
@@ -73,60 +69,34 @@ public final class VideoView: ExpoView, AVPlayerViewControllerDelegate {
   }
 
   func enterFullscreen() {
-    if isFullscreen {
-      return
-    }
-    let selectorName = "enterFullScreenAnimated:completionHandler:"
-    let selectorToForceFullScreenMode = NSSelectorFromString(selectorName)
-
-    if playerViewController.responds(to: selectorToForceFullScreenMode) {
-      playerViewController.perform(selectorToForceFullScreenMode, with: true, with: nil)
-    } else {
+    let tvOSFallback = {
       #if os(tvOS)
       // For TV, save the currently playing state,
       // remove the view controller from its superview,
       // and present the view controller normally
-      wasPlaying = player?.isPlaying == true
+      self.wasPlaying = self.player?.isPlaying == true
       self.playerViewController.view.removeFromSuperview()
       self.reactViewController().present(self.playerViewController, animated: true)
-      onFullscreenEnter()
-      isFullscreen = true
+      self.onFullscreenEnter()
+      self.isFullscreen = true
       #endif
     }
+    playerViewController.enterFullscreen(selectorUnsupportedFallback: tvOSFallback)
   }
 
   func exitFullscreen() {
-    if !isFullscreen {
-      return
-    }
-    let selectorName = "exitFullScreenAnimated:completionHandler:"
-    let selectorToExitFullScreenMode = NSSelectorFromString(selectorName)
-
-    if playerViewController.responds(to: selectorToExitFullScreenMode) {
-      playerViewController.perform(selectorToExitFullScreenMode, with: true, with: nil)
-    }
+    playerViewController.exitFullscreen()
+    #if os(tvOS)
+    self.isFullscreen = false
+    #endif
   }
 
   func startPictureInPicture() throws {
-    if !AVPictureInPictureController.isPictureInPictureSupported() {
-      throw PictureInPictureUnsupportedException()
-    }
-
-    let selectorName = "startPictureInPicture"
-    let selectorToStartPictureInPicture = NSSelectorFromString(selectorName)
-
-    if playerViewController.responds(to: selectorToStartPictureInPicture) {
-      playerViewController.perform(selectorToStartPictureInPicture)
-    }
+    try playerViewController.startPictureInPicture()
   }
 
   func stopPictureInPicture() {
-    let selectorName = "stopPictureInPicture"
-    let selectorToStopPictureInPicture = NSSelectorFromString(selectorName)
-
-    if playerViewController.responds(to: selectorToStopPictureInPicture) {
-      playerViewController.perform(selectorToStopPictureInPicture)
-    }
+    playerViewController.stopPictureInPicture()
   }
 
   // MARK: - AVPlayerViewControllerDelegate
@@ -162,7 +132,6 @@ public final class VideoView: ExpoView, AVPlayerViewControllerDelegate {
     willBeginFullScreenPresentationWithAnimationCoordinator coordinator: UIViewControllerTransitionCoordinator
   ) {
     onFullscreenEnter()
-    isFullscreen = true
   }
 
   public func playerViewController(
@@ -171,27 +140,27 @@ public final class VideoView: ExpoView, AVPlayerViewControllerDelegate {
   ) {
     // Platform's behavior is to pause the player when exiting the fullscreen mode.
     // It seems better to continue playing, so we resume the player once the dismissing animation finishes.
-    let wasPlaying = player?.ref.timeControlStatus == .playing
+    let wasPlaying = player?.isPlaying ?? false
 
     coordinator.animate(alongsideTransition: nil) { context in
-      if !context.isCancelled {
-        if wasPlaying {
+      if !context.isCancelled && wasPlaying {
+        DispatchQueue.main.async {
           self.player?.ref.play()
         }
+      }
+
+      if !context.isCancelled {
         self.onFullscreenExit()
-        self.isFullscreen = false
       }
     }
   }
   #endif
 
   public func playerViewControllerDidStartPictureInPicture(_ playerViewController: AVPlayerViewController) {
-    isInPictureInPicture = true
     onPictureInPictureStart()
   }
 
   public func playerViewControllerDidStopPictureInPicture(_ playerViewController: AVPlayerViewController) {
-    isInPictureInPicture = false
     onPictureInPictureStop()
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stepincto/expo-video",
   "title": "Expo Video",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "originalUpstreamVersion": "2.2.2", 
   "description": "A cross-platform, performant video component for React Native and Expo with Web support",
   "main": "build/index.js",
@@ -36,12 +36,11 @@
   "devDependencies": {
     "@types/react": "^19.1.9",
     "@types/react-dom": "^19.1.7",
-    "expo-module-scripts": "^4.1.10",
+    "expo-module-scripts": "^5.0.8",
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "expo": "^53.0.0",
-    "expo-modules-core": ">=2.4 <2.6",
+    "expo": "^54.0.0",
     "react": ">=18",
     "react-native": ">=0.75"
   },

package/src/VideoModule.ts

@@ -1,5 +1,7 @@
 import NativeVideoModule from './NativeVideoModule';
 
+const globalCacheOperations = new Map<string, Promise<boolean>>(); // stores the promises that are currently caching files
+
 /**
  * Returns whether the current device supports Picture in Picture (PiP) mode.
  *
@@ -46,8 +48,33 @@ export function getCurrentVideoCacheSize(): number {
   return NativeVideoModule.getCurrentVideoCacheSize();
 }
 
+// export async function preCacheVideoAsync(url: string): Promise<boolean> {
+//   return NativeVideoModule.preCacheVideoAsync(url);
+// }
+
+// Modify the existing function
 export async function preCacheVideoAsync(url: string): Promise<boolean> {
-  return NativeVideoModule.preCacheVideoAsync(url);
+  // If already caching, return the existing promise
+  if (globalCacheOperations.has(url)) {
+    return await globalCacheOperations.get(url)!;
+  }
+
+  // Start new caching operation with proper error handling
+  const cachingPromise = NativeVideoModule.preCacheVideoAsync(url).catch((error) => {
+    // Ensure cleanup happens even on native errors
+    globalCacheOperations.delete(url);
+    throw error;
+  });
+  
+  globalCacheOperations.set(url, cachingPromise);
+
+  try {
+    const result = await cachingPromise;
+    return result;
+  } finally {
+    // Always cleanup, even if the promise was already cleaned up in catch
+    globalCacheOperations.delete(url);
+  }
 }
 
 export async function preCacheVideoPartialAsync(url: string, chunkSize?: number): Promise<boolean> {

package/src/VideoView.tsx

@@ -61,13 +61,38 @@ export class VideoView extends PureComponent<VideoViewProps> {
   }
 
   render(): ReactNode {
-    const { player, ...props } = this.props;
+    const { player, allowsFullscreen, ...props } = this.props;
     const playerId = getPlayerId(player);
 
+    if (allowsFullscreen !== undefined) {
+      console.warn(
+        'The `allowsFullscreen` prop is deprecated and will be removed in a future release. Use `fullscreenOptions` prop instead.'
+      );
+    }
+
+    const fullscreenOptions = {
+      enable: allowsFullscreen,
+      ...props.fullscreenOptions,
+    };
+
     if (NativeTextureVideoView && this.props.surfaceType === 'textureView') {
-      return <NativeTextureVideoView {...props} player={playerId} ref={this.nativeRef} />;
+      return (
+        <NativeTextureVideoView
+          {...props}
+          fullscreenOptions={fullscreenOptions}
+          player={playerId}
+          ref={this.nativeRef}
+        />
+      );
     }
-    return <NativeVideoView {...props} player={playerId} ref={this.nativeRef} />;
+    return (
+      <NativeVideoView
+        {...props}
+        fullscreenOptions={fullscreenOptions}
+        player={playerId}
+        ref={this.nativeRef}
+      />
+    );
   }
 }
 

package/src/VideoView.types.ts

@@ -20,6 +20,56 @@ export type VideoContentFit = 'contain' | 'cover' | 'fill';
  */
 export type SurfaceType = 'textureView' | 'surfaceView';
 
+/**
+ * Describes the orientation of the video in fullscreen mode. Available values are:
+ * - `default`: The video is displayed in any of the available device rotations.
+ * - `portrait`: The video is displayed in one of two available portrait orientations and rotates between them.
+ * - `portraitUp`: The video is displayed in the portrait orientation - the notch of the phone points upwards.
+ * - `portraitDown`: The video is displayed in the portrait orientation - the notch of the phone points downwards.
+ * - `landscape`: The video is displayed in one of two available landscape orientations and rotates between them.
+ * - `landscapeLeft`: The video is displayed in the left landscape orientation - the notch of the phone is in the left palm of the user.
+ * - `landscapeRight`: The video is displayed in the right landscape orientation - the notch of the phone is in the right palm of the user.
+ */
+export type FullscreenOrientation =
+  | 'default'
+  | 'portrait'
+  | 'portraitUp'
+  | 'portraitDown'
+  | 'landscape'
+  | 'landscapeLeft'
+  | 'landscapeRight';
+
+/**
+ * Describes the options for fullscreen video mode.
+ */
+export type FullscreenOptions = {
+  /**
+   * Specifies whether the fullscreen mode should be available to the user. When `false`, the fullscreen button will be hidden in the player.
+   * Equivalent to the `allowsFullscreen` prop.
+   * @default true
+   */
+  enable?: boolean;
+  /**
+   * Specifies the orientation of the video in fullscreen mode.
+   * @default 'default'
+   * @platform android
+   * @platform ios
+   */
+  orientation?: FullscreenOrientation;
+  /**
+   * Specifies whether the app should exit fullscreen mode when the device is rotated to a different orientation than the one specified in the `orientation` prop.
+   * For example, if the `orientation` prop is set to `landscape` and the device is rotated to `portrait`, the app will exit fullscreen mode.
+   *
+   * > This prop will have no effect if the `orientation` prop is set to `default`.
+   * > The `VideoView` will never auto-exit fullscreen when the device auto-rotate feature has been disabled in settings.
+   *
+   * @default false
+   * @platform android
+   * @platform ios
+   */
+  autoExitOnRotate?: boolean;
+};
+
 export interface VideoViewProps extends ViewProps {
   /**
    * A video player instance. Use [`useVideoPlayer()`](#usevideoplayersource-setup) hook to create one.
@@ -41,10 +91,17 @@ export interface VideoViewProps extends ViewProps {
 
   /**
    * Determines whether fullscreen mode is allowed or not.
+   *
+   * > Note: This option has been deprecated in favor of the `fullscreenOptions` prop and will be disabled in the future.
    * @default true
    */
   allowsFullscreen?: boolean;
 
+  /**
+   * Determines the fullscreen mode options.
+   */
+  fullscreenOptions?: FullscreenOptions;
+
   /**
    * Determines whether the timecodes should be displayed or not.
    * @default true

package/src/VideoView.web.tsx

@@ -30,6 +30,8 @@ export function isPictureInPictureSupported(): boolean {
 
 export const VideoView = forwardRef((props: { player?: VideoPlayer } & VideoViewProps, ref) => {
   const videoRef = useRef<null | HTMLVideoElement>(null);
+  const fullscreenEnabled =
+    props.fullscreenOptions?.enable ?? props.allowsFullscreen ?? true;
   const mediaNodeRef = useRef<null | MediaElementAudioSourceNode>(null);
   const hasToSetupAudioContext = useRef(false);
   const fullscreenChangeListener = useRef<null | (() => void)>(null);
@@ -46,7 +48,7 @@ export const VideoView = forwardRef((props: { player?: VideoPlayer } & VideoView
 
   useImperativeHandle(ref, () => ({
     enterFullscreen: async () => {
-      if (!props.allowsFullscreen) {
+      if (!fullscreenEnabled) {
         return;
       }
       await videoRef.current?.requestFullscreen();
@@ -182,7 +184,7 @@ export const VideoView = forwardRef((props: { player?: VideoPlayer } & VideoView
   return (
     <video
       controls={props.nativeControls ?? true}
-      controlsList={props.allowsFullscreen ? undefined : 'nofullscreen'}
+      controlsList={fullscreenEnabled ? undefined : 'nofullscreen'}
       crossOrigin={props.crossOrigin}
       style={{
         ...mapStyles(props.style),

package/src/index.ts

@@ -10,7 +10,13 @@ export {
 export { VideoView } from './VideoView';
 export { useVideoPlayer } from './VideoPlayer';
 
-export { VideoContentFit, VideoViewProps, SurfaceType } from './VideoView.types';
+export {
+  VideoContentFit,
+  VideoViewProps,
+  SurfaceType,
+  FullscreenOptions,
+  FullscreenOrientation,
+} from './VideoView.types';
 export { VideoThumbnail } from './VideoThumbnail';
 
 export { createVideoPlayer } from './VideoPlayer';