@stepincto/expo-video 1.0.3 → 1.0.5

package/build/VideoModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VideoModule.d.ts","sourceRoot":"","sources":["../src/VideoModule.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAErD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEvE;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAED,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAEtE;AAED,wBAAsB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAEjG;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAEhE"}
+{"version":3,"file":"VideoModule.d.ts","sourceRoot":"","sources":["../src/VideoModule.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAErD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEvE;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAOD,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAsBtE;AAED,wBAAsB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAEjG;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAEhE"}

package/build/VideoModule.js

@@ -1,4 +1,5 @@
 import NativeVideoModule from './NativeVideoModule';
+const globalCacheOperations = new Map(); // stores the promises that are currently caching files
 /**
  * Returns whether the current device supports Picture in Picture (PiP) mode.
  *
@@ -41,8 +42,30 @@ export function setVideoCacheSizeAsync(sizeBytes) {
 export function getCurrentVideoCacheSize() {
     return NativeVideoModule.getCurrentVideoCacheSize();
 }
+// export async function preCacheVideoAsync(url: string): Promise<boolean> {
+//   return NativeVideoModule.preCacheVideoAsync(url);
+// }
+// Modify the existing function
 export async function preCacheVideoAsync(url) {
-    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, chunkSize) {
     return NativeVideoModule.preCacheVideoPartialAsync(url, chunkSize);

package/build/VideoModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"VideoModule.js","sourceRoot":"","sources":["../src/VideoModule.ts"],"names":[],"mappings":"AAAA,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B;IACzC,OAAO,iBAAiB,CAAC,2BAA2B,EAAE,CAAC;AACzD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,iBAAiB,CAAC,oBAAoB,EAAE,CAAC;AAClD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,sBAAsB,CAAC,SAAiB;IACtD,OAAO,iBAAiB,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;AAC7D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB;IACtC,OAAO,iBAAiB,CAAC,wBAAwB,EAAE,CAAC;AACtD,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,GAAW;IAClD,OAAO,iBAAiB,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,GAAW,EAAE,SAAkB;IAC7E,OAAO,iBAAiB,CAAC,yBAAyB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;AACrE,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,GAAW;IAC5C,OAAO,iBAAiB,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;AACnD,CAAC","sourcesContent":["import NativeVideoModule from './NativeVideoModule';\n\n/**\n * Returns whether the current device supports Picture in Picture (PiP) mode.\n *\n * @returns A `boolean` which is `true` if the device supports PiP mode, and `false` otherwise.\n * @platform android\n * @platform ios\n */\nexport function isPictureInPictureSupported(): boolean {\n  return NativeVideoModule.isPictureInPictureSupported();\n}\n\n/**\n * Clears all video cache.\n * > This function can be called only if there are no existing `VideoPlayer` instances.\n *\n * @returns A promise that fulfills after the cache has been cleaned.\n * @platform android\n * @platform ios\n */\nexport function clearVideoCacheAsync(): Promise<void> {\n  return NativeVideoModule.clearVideoCacheAsync();\n}\n\n/**\n * Sets desired video cache size in bytes. The default video cache size is 1GB. Value set by this function is persistent.\n * The cache size is not guaranteed to be exact and the actual cache size may be slightly larger. The cache is evicted on a least-recently-used basis.\n * > This function can be called only if there are no existing `VideoPlayer` instances.\n *\n * @returns A promise that fulfills after the cache size has been set.\n * @platform android\n * @platform ios\n */\nexport function setVideoCacheSizeAsync(sizeBytes: number): Promise<void> {\n  return NativeVideoModule.setVideoCacheSizeAsync(sizeBytes);\n}\n\n/**\n * Returns the space currently occupied by the video cache in bytes.\n *\n * @platform android\n * @platform ios\n */\nexport function getCurrentVideoCacheSize(): number {\n  return NativeVideoModule.getCurrentVideoCacheSize();\n}\n\nexport async function preCacheVideoAsync(url: string): Promise<boolean> {\n  return NativeVideoModule.preCacheVideoAsync(url);\n}\n\nexport async function preCacheVideoPartialAsync(url: string, chunkSize?: number): Promise<boolean> {\n  return NativeVideoModule.preCacheVideoPartialAsync(url, chunkSize);\n}\n\nexport function isVideoCachedAsync(url: string): Promise<boolean> {\n  return NativeVideoModule.isVideoCachedAsync(url);\n}\n"]}
+{"version":3,"file":"VideoModule.js","sourceRoot":"","sources":["../src/VideoModule.ts"],"names":[],"mappings":"AAAA,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AAEpD,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAA4B,CAAC,CAAC,uDAAuD;AAE1H;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B;IACzC,OAAO,iBAAiB,CAAC,2BAA2B,EAAE,CAAC;AACzD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,iBAAiB,CAAC,oBAAoB,EAAE,CAAC;AAClD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,sBAAsB,CAAC,SAAiB;IACtD,OAAO,iBAAiB,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;AAC7D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB;IACtC,OAAO,iBAAiB,CAAC,wBAAwB,EAAE,CAAC;AACtD,CAAC;AAED,4EAA4E;AAC5E,sDAAsD;AACtD,IAAI;AAEJ,+BAA+B;AAC/B,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,GAAW;IAClD,kDAAkD;IAClD,IAAI,qBAAqB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,OAAO,MAAM,qBAAqB,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;IAC/C,CAAC;IAED,yDAAyD;IACzD,MAAM,cAAc,GAAG,iBAAiB,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;QAC/E,+CAA+C;QAC/C,qBAAqB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAClC,MAAM,KAAK,CAAC;IACd,CAAC,CAAC,CAAC;IAEH,qBAAqB,CAAC,GAAG,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;IAE/C,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC;QACpC,OAAO,MAAM,CAAC;IAChB,CAAC;YAAS,CAAC;QACT,sEAAsE;QACtE,qBAAqB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACpC,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,GAAW,EAAE,SAAkB;IAC7E,OAAO,iBAAiB,CAAC,yBAAyB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;AACrE,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,GAAW;IAC5C,OAAO,iBAAiB,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;AACnD,CAAC","sourcesContent":["import NativeVideoModule from './NativeVideoModule';\n\nconst globalCacheOperations = new Map<string, Promise<boolean>>(); // stores the promises that are currently caching files\n\n/**\n * Returns whether the current device supports Picture in Picture (PiP) mode.\n *\n * @returns A `boolean` which is `true` if the device supports PiP mode, and `false` otherwise.\n * @platform android\n * @platform ios\n */\nexport function isPictureInPictureSupported(): boolean {\n  return NativeVideoModule.isPictureInPictureSupported();\n}\n\n/**\n * Clears all video cache.\n * > This function can be called only if there are no existing `VideoPlayer` instances.\n *\n * @returns A promise that fulfills after the cache has been cleaned.\n * @platform android\n * @platform ios\n */\nexport function clearVideoCacheAsync(): Promise<void> {\n  return NativeVideoModule.clearVideoCacheAsync();\n}\n\n/**\n * Sets desired video cache size in bytes. The default video cache size is 1GB. Value set by this function is persistent.\n * The cache size is not guaranteed to be exact and the actual cache size may be slightly larger. The cache is evicted on a least-recently-used basis.\n * > This function can be called only if there are no existing `VideoPlayer` instances.\n *\n * @returns A promise that fulfills after the cache size has been set.\n * @platform android\n * @platform ios\n */\nexport function setVideoCacheSizeAsync(sizeBytes: number): Promise<void> {\n  return NativeVideoModule.setVideoCacheSizeAsync(sizeBytes);\n}\n\n/**\n * Returns the space currently occupied by the video cache in bytes.\n *\n * @platform android\n * @platform ios\n */\nexport function getCurrentVideoCacheSize(): number {\n  return NativeVideoModule.getCurrentVideoCacheSize();\n}\n\n// export async function preCacheVideoAsync(url: string): Promise<boolean> {\n//   return NativeVideoModule.preCacheVideoAsync(url);\n// }\n\n// Modify the existing function\nexport async function preCacheVideoAsync(url: string): Promise<boolean> {\n  // If already caching, return the existing promise\n  if (globalCacheOperations.has(url)) {\n    return await globalCacheOperations.get(url)!;\n  }\n\n  // Start new caching operation with proper error handling\n  const cachingPromise = NativeVideoModule.preCacheVideoAsync(url).catch((error) => {\n    // Ensure cleanup happens even on native errors\n    globalCacheOperations.delete(url);\n    throw error;\n  });\n  \n  globalCacheOperations.set(url, cachingPromise);\n\n  try {\n    const result = await cachingPromise;\n    return result;\n  } finally {\n    // Always cleanup, even if the promise was already cleaned up in catch\n    globalCacheOperations.delete(url);\n  }\n}\n\nexport async function preCacheVideoPartialAsync(url: string, chunkSize?: number): Promise<boolean> {\n  return NativeVideoModule.preCacheVideoPartialAsync(url, chunkSize);\n}\n\nexport function isVideoCachedAsync(url: string): Promise<boolean> {\n  return NativeVideoModule.isVideoCachedAsync(url);\n}\n"]}

package/ios/Cache/CachableRequest.swift

@@ -17,8 +17,6 @@ class CachableRequest: Equatable, Hashable {
   var response: URLResponse?
   private(set) var receivedData = Data()
   private let dataOffset: Int64
-  private static var fileLocks: [String: NSLock] = [:]
-  private static let fileLocksQueue = DispatchQueue(label: "expo-video-cache-file-locks")
 
   init(loadingRequest: AVAssetResourceLoadingRequest, dataTask: URLSessionDataTask, dataRequest: AVAssetResourceLoadingDataRequest) {
     self.loadingRequest = loadingRequest
@@ -32,41 +30,8 @@ class CachableRequest: Equatable, Hashable {
   }
 
   func saveData(to cachedResource: CachedResource) {
-    // 1. Check if file is fully cached
-    if let mediaInfo = cachedResource.mediaInfo {
-      let expectedLength = Int(mediaInfo.expectedContentLength)
-      let ranges = mediaInfo.loadedDataRanges
-      if ranges.count == 1, ranges[0].0 == 0, ranges[0].1 == expectedLength - 1 {
-        // Already fully cached, do not write
-        return
-      }
-    }
-
-    // 2. Acquire per-file lock
-    let filePath = cachedResource.dataPath
-    let lock: NSLock = Self.fileLocksQueue.sync {
-      if let l = Self.fileLocks[filePath] { return l }
-      let l = NSLock()
-      Self.fileLocks[filePath] = l
-      return l
-    }
-    if !lock.try() {
-      // Another writer is active, skip this write
-      return
-    }
-    defer { lock.unlock() }
-
-    // 3. Write only missing data
-    let offset = dataOffset
-    let length = receivedData.count
-    let end = offset + Int64(length) - 1
-    if cachedResource.canRespondWithData(from: offset, to: end) {
-      // This range is already cached, skip
-      return
-    }
-    Task {
-      await cachedResource.writeData(data: receivedData, offset: offset)
-    }
+    // Disabled: Player is now read-only with respect to the cache.
+    // Do nothing.
   }
 
   static func == (lhs: CachableRequest, rhs: CachableRequest) -> Bool {

package/ios/Cache/CachedResource.swift

@@ -10,7 +10,7 @@ import ExpoModulesCore
  */
 class CachedResource {
   private let url: URL
-  internal let dataPath: String
+  private let dataPath: String
   private let fileHandle: MediaFileHandle
   private(set) var mediaInfo: MediaInfo?
 

package/ios/Cache/MediaFileHandle.swift

@@ -26,16 +26,17 @@ internal class MediaFileHandle {
     return attributes?[.size] as? Int ?? 0
   }
 
-  private var fileUrl: URL? {
-    URL(string: filePath)
+  private var fileUrl: URL {
+    URL(fileURLWithPath: filePath)
   }
 
   init(filePath: String) {
     self.filePath = filePath
 
-    if let fileUrl {
-      VideoCacheManager.shared.registerOpenFile(at: fileUrl)
-    }
+    // Use fileURLWithPath for proper file URL creation
+    let url = fileUrl
+    VideoCacheManager.shared.registerOpenFile(at: url)
+    print("[MediaFileHandle] Registering file URL: \(url.path)")
 
     if !FileManager.default.fileExists(atPath: filePath) {
       FileManager.default.createFile(atPath: filePath, contents: nil, attributes: nil)
@@ -43,9 +44,10 @@ internal class MediaFileHandle {
   }
 
   deinit {
-    if let fileUrl {
-      VideoCacheManager.shared.unregisterOpenFile(at: fileUrl)
-    }
+    // Use fileURLWithPath for proper file URL creation
+    let url = fileUrl
+    VideoCacheManager.shared.unregisterOpenFile(at: url)
+    print("[MediaFileHandle] Unregistering file URL: \(url.path)")
     guard FileManager.default.fileExists(atPath: filePath) else {
       return
     }

package/ios/Cache/MediaInfo.swift

@@ -7,6 +7,7 @@ class MediaInfo: Codable {
   var mimeType: String?
   var headerFields: [String: String]?
   var savePath: String
+  private var shouldAutoUnregister: Bool = true
 
   // Tuples can't be encoded/decoded, so we workaround that with an array
   private var loadedDataRangesArr: [[Int]] = []
@@ -21,24 +22,57 @@ class MediaInfo: Codable {
 
   private enum CodingKeys: String, CodingKey {
     case expectedContentLength, supportsByteRangeAccess, mimeType, loadedDataRangesArr, headerFields, savePath
+    // Note: shouldAutoUnregister is not encoded/decoded as it's runtime-only
+  }
+  
+  // Custom decoding to handle shouldAutoUnregister
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    expectedContentLength = try container.decode(Int64.self, forKey: .expectedContentLength)
+    supportsByteRangeAccess = try container.decode(Bool.self, forKey: .supportsByteRangeAccess)
+    mimeType = try container.decodeIfPresent(String.self, forKey: .mimeType)
+    loadedDataRangesArr = try container.decode([[Int]].self, forKey: .loadedDataRangesArr)
+    headerFields = try container.decodeIfPresent([String: String].self, forKey: .headerFields)
+    savePath = try container.decode(String.self, forKey: .savePath)
+    shouldAutoUnregister = true // Default to true for decoded objects
+  }
+  
+  // Custom encoding to exclude shouldAutoUnregister
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(expectedContentLength, forKey: .expectedContentLength)
+    try container.encode(supportsByteRangeAccess, forKey: .supportsByteRangeAccess)
+    try container.encodeIfPresent(mimeType, forKey: .mimeType)
+    try container.encode(loadedDataRangesArr, forKey: .loadedDataRangesArr)
+    try container.encodeIfPresent(headerFields, forKey: .headerFields)
+    try container.encode(savePath, forKey: .savePath)
   }
 
-  init(expectedContentLength: Int64, mimeType: String?, supportsByteRangeAccess: Bool, headerFields: [String: String]?, savePath: String) {
+  init(expectedContentLength: Int64, mimeType: String?, supportsByteRangeAccess: Bool, headerFields: [String: String]?, savePath: String, autoRegister: Bool = true) {
     self.mimeType = mimeType
     self.supportsByteRangeAccess = supportsByteRangeAccess
     self.expectedContentLength = expectedContentLength
     self.headerFields = headerFields
     self.savePath = savePath
+    self.shouldAutoUnregister = autoRegister
     self.loadedDataRanges = loadedDataRanges
 
-    if let url = URL(string: savePath) {
-      VideoCacheManager.shared.registerOpenFile(at: url)
+    // Only auto-register if requested (prevents double registration)
+    if autoRegister {
+      // Use fileURLWithPath for proper file URL creation instead of URL(string:)
+      let fileUrl = URL(fileURLWithPath: savePath)
+      VideoCacheManager.shared.registerOpenFile(at: fileUrl)
+      print("[MediaInfo] Registering file URL: \(fileUrl.path)")
     }
   }
 
   deinit {
-    if let url = URL(string: savePath) {
-      VideoCacheManager.shared.unregisterOpenFile(at: url)
+    // Only unregister if we auto-registered (prevents double unregistration)
+    if shouldAutoUnregister {
+      // Use fileURLWithPath for proper file URL creation instead of URL(string:)
+      let fileUrl = URL(fileURLWithPath: savePath)
+      VideoCacheManager.shared.unregisterOpenFile(at: fileUrl)
+      print("[MediaInfo] Unregistering file URL: \(fileUrl.path)")
     }
   }
 
@@ -50,7 +84,8 @@ class MediaInfo: Codable {
         mimeType: mediaInfo.mimeType,
         supportsByteRangeAccess: mediaInfo.supportsByteRangeAccess,
         headerFields: mediaInfo.headerFields,
-        savePath: mediaInfo.savePath)
+        savePath: mediaInfo.savePath,
+        autoRegister: true) // Default behavior for loaded MediaInfo
       self.loadedDataRanges = mediaInfo.loadedDataRanges
     } catch {
       return nil

package/ios/Cache/VideoCacheManager.swift

@@ -13,7 +13,17 @@ class VideoCacheManager {
   private let maxCacheSizeKey = "\(VideoCacheManager.expoVideoCacheScheme)/maxCacheSize"
 
   // Files currently being used/modified by the player - they will be skipped when clearing the cache
-  private var openFiles: Set<URL> = Set()
+  private let openFilesQueue = DispatchQueue(label: "\(VideoCacheManager.expoVideoCacheScheme)-openFiles-queue", attributes: .concurrent)
+  private var _openFiles: Set<URL> = Set()
+  
+  private var openFiles: Set<URL> {
+    get {
+      return openFilesQueue.sync { _openFiles }
+    }
+    set {
+      openFilesQueue.async(flags: .barrier) { self._openFiles = newValue }
+    }
+  }
 
   // All cache commands such as clean or adding new data should be run on this queue
   let cacheQueue = DispatchQueue(label: "\(VideoCacheManager.expoVideoCacheScheme)-dispatch-queue")
@@ -23,11 +33,29 @@ class VideoCacheManager {
   }
 
   func registerOpenFile(at url: URL) {
-    openFiles.insert(url)
+    guard url.isFileURL else {
+      print("[VideoCacheManager] Warning: Attempting to register non-file URL: \(url)")
+      return
+    }
+    
+    openFilesQueue.async(flags: .barrier) { [weak self] in
+      guard let self = self else { return }
+      self._openFiles.insert(url)
+      print("[VideoCacheManager] Registered file: \(url.path)")
+    }
   }
 
   func unregisterOpenFile(at url: URL) {
-    openFiles.remove(url)
+    guard url.isFileURL else {
+      print("[VideoCacheManager] Warning: Attempting to unregister non-file URL: \(url)")
+      return
+    }
+    
+    openFilesQueue.async(flags: .barrier) { [weak self] in
+      guard let self = self else { return }
+      self._openFiles.remove(url)
+      print("[VideoCacheManager] Unregistered file: \(url.path)")
+    }
   }
 
   func setMaxCacheSize(newSize: Int) throws {
@@ -177,7 +205,9 @@ class VideoCacheManager {
   }
 
   private func fileIsOpen(url: URL) -> Bool {
-    return openFiles.contains(url) || openFiles.contains { $0.relativePath == url.relativePath }
+    return openFilesQueue.sync {
+      return _openFiles.contains(url) || _openFiles.contains { $0.relativePath == url.relativePath }
+    }
   }
 }
 
@@ -210,6 +240,14 @@ extension VideoCacheManager {
     let fileUrl = URL(fileURLWithPath: saveFilePath)
     let mediaInfoPath = saveFilePath + VideoCacheManager.mediaInfoSuffix
 
+    // CRITICAL FIX: Register file as open BEFORE any operations to prevent cache cleanup race condition
+    VideoCacheManager.shared.registerOpenFile(at: fileUrl)
+    
+    defer {
+      // Always unregister when done, even if there's an error
+      VideoCacheManager.shared.unregisterOpenFile(at: fileUrl)
+    }
+
     // Ensure parent directory exists before writing file
     let parentDir = fileUrl.deletingLastPathComponent()
     do {
@@ -226,14 +264,23 @@ extension VideoCacheManager {
     let mimeType = response.mimeType
     let supportsByteRangeAccess = true
     let headerFields: [String: String]? = nil
-    let mediaInfo = MediaInfo(expectedContentLength: expectedLength, mimeType: mimeType, supportsByteRangeAccess: supportsByteRangeAccess, headerFields: headerFields, savePath: mediaInfoPath)
+    
+    // Create MediaInfo without auto-registration (we already registered above)
+    let mediaInfo = MediaInfo(
+      expectedContentLength: expectedLength, 
+      mimeType: mimeType, 
+      supportsByteRangeAccess: supportsByteRangeAccess, 
+      headerFields: headerFields, 
+      savePath: mediaInfoPath,
+      autoRegister: false
+    )
     mediaInfo.setLoadedDataRanges([(0, data.count - 1)])
     mediaInfo.saveToFile()
 
     // Print current cache size
     let cacheSize = VideoCacheManager.shared.getCacheDirectorySize()
     print("[expo-video] Cache size after caching: \(cacheSize) bytes")
-    return false
+    return true
   }
 
   static func preCacheVideoPartialAsync(from urlString: String, chunkSize: Int = 1_048_576) async throws -> Bool {

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stepincto/expo-video",
   "title": "Expo Video",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "originalUpstreamVersion": "2.2.2", 
   "description": "A cross-platform, performant video component for React Native and Expo with Web support",
   "main": "build/index.js",

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> {