@stepincto/expo-video 1.0.0

package/ios/Cache/VideoCacheManager.swift

@@ -0,0 +1,338 @@
+import ExpoModulesCore
+
+class VideoCacheManager {
+  static let defaultMaxCacheSize = 1_024_000_000 // 1GB
+  static let defaultAutoCleanCache = true
+  static let expoVideoCacheScheme = "expo-video-cache"
+  static let expoVideoCacheDirectory = "expo-video-cache"
+  static let mediaInfoSuffix = "&mediaInfo"
+
+  static let shared = VideoCacheManager()
+  private let defaults = UserDefaults.standard
+
+  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()
+
+  // All cache commands such as clean or adding new data should be run on this queue
+  let cacheQueue = DispatchQueue(label: "\(VideoCacheManager.expoVideoCacheScheme)-dispatch-queue")
+
+  var maxCacheSize: Int {
+    defaults.maybeInteger(forKey: maxCacheSizeKey) ?? Self.defaultMaxCacheSize
+  }
+
+  func registerOpenFile(at url: URL) {
+    openFiles.insert(url)
+  }
+
+  func unregisterOpenFile(at url: URL) {
+    openFiles.remove(url)
+  }
+
+  func setMaxCacheSize(newSize: Int) throws {
+    if VideoManager.shared.hasRegisteredPlayers {
+      throw VideoCacheException("Cannot change the cache size while there are active players")
+    }
+
+    defaults.setValue(newSize, forKey: maxCacheSizeKey)
+    ensureCacheSize()
+  }
+
+  func ensureCacheSize() {
+    cacheQueue.async { [weak self] in
+      guard let self else {
+        return
+      }
+
+      do {
+        try self.limitCacheSize(to: maxCacheSize)
+      } catch {
+        log.warn("Failed to auto clean expo-video cache")
+      }
+    }
+  }
+
+  func clearAllCache() async throws {
+    return try await withCheckedThrowingContinuation { continuation in
+      cacheQueue.async { [weak self] in
+        do {
+          try self?.deleteAllFilesInCacheDirectory()
+          continuation.resume()
+        } catch {
+          continuation.resume(throwing: error)
+        }
+      }
+    }
+  }
+
+  func ensureCacheIntegrity(forSavePath videoFilePath: String) {
+    let mediaInfoPath = videoFilePath + Self.mediaInfoSuffix
+    let videoFileExists = FileManager.default.fileExists(atPath: videoFilePath)
+    let mediaInfoExists = FileManager.default.fileExists(atPath: mediaInfoPath)
+
+    // If mediaInfo exists and the corresponding data file doesn't we need to remove to avoid false data in
+    // the `loadedDataRanges` field
+    if mediaInfoExists && !videoFileExists {
+      try? FileManager.default.removeItem(atPath: mediaInfoPath)
+    }
+  }
+
+  func getCacheDirectorySize() -> Int64 {
+    guard let folderUrl = getCacheDirectory() else {
+      return 0
+    }
+    let fileManager = FileManager.default
+    var totalSize: Int64 = 0
+
+    guard let enumerator = fileManager.enumerator(at: folderUrl, includingPropertiesForKeys: [.fileSizeKey], options: .skipsHiddenFiles) else {
+      return 0
+    }
+
+    for case let fileURL as URL in enumerator {
+      guard let fileAttributes = try? fileURL.resourceValues(forKeys: [.fileSizeKey]) else {
+        continue
+      }
+      if let fileSize = fileAttributes.fileSize {
+        totalSize += Int64(fileSize)
+      }
+    }
+
+    return totalSize
+  }
+
+  private func limitCacheSize(to maxSize: Int) throws {
+    let allFileURLs = getVideoFilesUrls()
+
+    var totalSize: Int64 = 0
+    var fileInfo = [(url: URL, size: Int64, accessDate: Date)]()
+
+    for url in allFileURLs {
+      let attributes = try FileManager.default.attributesOfItem(atPath: url.path)
+      let fileSize = attributes[.size] as? Int64 ?? 0
+      let accessDate = try url.resourceValues(forKeys: [.contentAccessDateKey]).contentAccessDate ?? Date.distantPast
+      totalSize += fileSize
+      fileInfo.append((url: url, size: fileSize, accessDate: accessDate))
+    }
+
+    if totalSize <= maxSize {
+      return
+    }
+
+    let deletableFileInfo = fileInfo.filter { !fileIsOpen(url: $0.url) }
+    let sortedFileInfo = deletableFileInfo.sorted { $0.accessDate < $1.accessDate }
+
+    for fileInfo in sortedFileInfo {
+      if totalSize <= maxSize {
+        continue
+      }
+      try removeVideoAndMimeTypeFile(at: fileInfo.url)
+      totalSize -= fileInfo.size
+    }
+  }
+
+  private func deleteAllFilesInCacheDirectory() throws {
+    if VideoManager.shared.hasRegisteredPlayers {
+      throw VideoCacheException("Cannot clear cache while there are active players")
+    }
+
+    guard let cacheDirectory = getCacheDirectory() else {
+      return
+    }
+
+    let fileUrls = try FileManager.default.contentsOfDirectory(at: cacheDirectory, includingPropertiesForKeys: nil, options: [])
+
+    for fileUrl in fileUrls {
+      try removeVideoAndMimeTypeFile(at: fileUrl)
+    }
+  }
+
+  private func removeVideoAndMimeTypeFile(at fileUrl: URL) throws {
+    let mimeTypeFileUrl = URL(string: "\(fileUrl.relativeString)\(Self.mediaInfoSuffix)")
+    try FileManager.default.removeItem(at: fileUrl)
+    if let mimeTypeFileUrl, FileManager.default.fileExists(atPath: mimeTypeFileUrl.relativePath) {
+      try FileManager.default.removeItem(at: mimeTypeFileUrl)
+    }
+  }
+
+  private func getCacheDirectory() -> URL? {
+    let cacheDirs = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)
+    if let cacheDir = cacheDirs.first {
+      return cacheDir.appendingPathComponent(VideoCacheManager.expoVideoCacheDirectory)
+    }
+    return nil
+  }
+
+  private func getVideoFilesUrls() -> [URL] {
+    guard let videoCacheDir = getCacheDirectory() else {
+      print("Failed to get the video cache directory.")
+      return []
+    }
+    let fileUrls = (try? FileManager.default.contentsOfDirectory(
+      at: videoCacheDir,
+      includingPropertiesForKeys: [.contentAccessDateKey, .contentModificationDateKey],
+      options: .skipsHiddenFiles)
+    ) ?? []
+    return fileUrls.filter { !$0.absoluteString.hasSuffix(Self.mediaInfoSuffix) }
+  }
+
+  private func fileIsOpen(url: URL) -> Bool {
+    return openFiles.contains(url) || openFiles.contains { $0.relativePath == url.relativePath }
+  }
+}
+
+// MARK: - Custom Caching Methods
+
+extension VideoCacheManager {
+  static func preCacheVideoAsync(from urlString: String) async throws -> Bool {
+    // Check if already cached (same logic as isVideoCachedAsync)
+    if let url = URL(string: urlString) {
+        let fileExtension = url.pathExtension
+        if let saveFilePath = VideoAsset.pathForUrl(url: url, fileExtension: fileExtension) {
+            let mediaInfoPath = saveFilePath + VideoCacheManager.mediaInfoSuffix
+            if let mediaInfo = MediaInfo(at: mediaInfoPath) {
+                let expectedLength = Int(mediaInfo.expectedContentLength)
+                let ranges = mediaInfo.loadedDataRanges
+                if ranges.count == 1, ranges[0].0 == 0, ranges[0].1 == expectedLength - 1 {
+                    print("[expo-video] File already fully cached, skipping download.")
+                    return true
+                }
+            }
+        }
+    }
+    guard let url = URL(string: urlString) else {
+      throw NSError(domain: "VideoCacheManager", code: 1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL string"])
+    }
+    let fileExtension = url.pathExtension
+    guard let saveFilePath = VideoAsset.pathForUrl(url: url, fileExtension: fileExtension) else {
+      throw NSError(domain: "VideoCacheManager", code: 2, userInfo: [NSLocalizedDescriptionKey: "Failed to create cache file path"])
+    }
+    let fileUrl = URL(fileURLWithPath: saveFilePath)
+    let mediaInfoPath = saveFilePath + VideoCacheManager.mediaInfoSuffix
+
+    let (data, response) = try await URLSession.shared.data(from: url)
+    try data.write(to: fileUrl, options: .atomic)
+
+    let expectedLength = Int64(data.count)
+    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)
+    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
+  }
+
+  static func preCacheVideoPartialAsync(from urlString: String, chunkSize: Int = 1_048_576) async throws -> Bool {
+    // Check if already cached (same logic as isVideoCachedAsync)
+    if let url = URL(string: urlString) {
+        let fileExtension = url.pathExtension
+        if let saveFilePath = VideoAsset.pathForUrl(url: url, fileExtension: fileExtension) {
+            let mediaInfoPath = saveFilePath + VideoCacheManager.mediaInfoSuffix
+            if let mediaInfo = MediaInfo(at: mediaInfoPath) {
+                let expectedLength = Int(mediaInfo.expectedContentLength)
+                let ranges = mediaInfo.loadedDataRanges
+                if ranges.count == 1, ranges[0].0 == 0, ranges[0].1 == expectedLength - 1 {
+                    print("[expo-video] File already fully cached, skipping download.")
+                    return true
+                }
+            }
+        }
+    }
+    guard let url = URL(string: urlString) else {
+      throw NSError(domain: "VideoCacheManager", code: 1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL string"])
+    }
+    let fileExtension = url.pathExtension
+    guard let saveFilePath = VideoAsset.pathForUrl(url: url, fileExtension: fileExtension) else {
+      throw NSError(domain: "VideoCacheManager", code: 2, userInfo: [NSLocalizedDescriptionKey: "Failed to create cache file path"])
+    }
+    let fileUrl = URL(fileURLWithPath: saveFilePath)
+    let mediaInfoPath = saveFilePath + VideoCacheManager.mediaInfoSuffix
+
+    // Ensure the cache directory exists (same as VideoAsset)
+    if let cacheDir = try? FileManager.default.url(for: .cachesDirectory, in: .userDomainMask, appropriateFor: nil, create: true) {
+        let videoCacheDir = cacheDir.appendingPathComponent(VideoCacheManager.expoVideoCacheScheme, isDirectory: true)
+        try? FileManager.default.createDirectory(at: videoCacheDir, withIntermediateDirectories: true)
+    }
+
+    // Ensure the file exists before opening for writing
+    if !FileManager.default.fileExists(atPath: fileUrl.path) {
+        FileManager.default.createFile(atPath: fileUrl.path, contents: nil, attributes: nil)
+    }
+    let fileHandle = try FileHandle(forWritingTo: fileUrl)
+    defer { try? fileHandle.close() }
+
+    // Restore these variable declarations:
+    var expectedLength: Int64 = 0
+    var mimeType: String? = nil
+    var supportsByteRangeAccess = true
+    var headerFields: [String: String]? = nil
+    var loadedRanges: [(Int, Int)] = []
+
+    // Make a HEAD request to get expectedLength and headers
+    var headRequest = URLRequest(url: url)
+    headRequest.httpMethod = "HEAD"
+    let (_, headResponse) = try await URLSession.shared.data(for: headRequest)
+    if let httpResponse = headResponse as? HTTPURLResponse {
+        if let contentLength = httpResponse.value(forHTTPHeaderField: "Content-Length"), let length = Int64(contentLength) {
+            expectedLength = length
+        }
+        mimeType = httpResponse.mimeType
+        supportsByteRangeAccess = httpResponse.value(forHTTPHeaderField: "Accept-Ranges") == "bytes"
+        headerFields = httpResponse.allHeaderFields as? [String: String]
+    }
+
+    var offset = 0
+    while Int64(offset) < expectedLength {
+      let end = min(offset + chunkSize - 1, Int(expectedLength) - 1)
+      var request = URLRequest(url: url)
+      request.setValue("bytes=\(offset)-\(end)", forHTTPHeaderField: "Range")
+      let (chunkData, _) = try await URLSession.shared.data(for: request)
+      try fileHandle.seek(toOffset: UInt64(offset))
+      try fileHandle.write(contentsOf: chunkData)
+      loadedRanges.append((offset, offset + chunkData.count - 1))
+      offset += chunkData.count
+
+      let mediaInfo = MediaInfo(expectedContentLength: expectedLength, mimeType: mimeType, supportsByteRangeAccess: supportsByteRangeAccess, headerFields: headerFields, savePath: mediaInfoPath)
+      mediaInfo.setLoadedDataRanges(loadedRanges)
+      mediaInfo.saveToFile()
+      let cacheSize = VideoCacheManager.shared.getCacheDirectorySize()
+      print("[expo-video] Cache size after chunk: \(cacheSize) bytes")
+    }
+    // Merge all ranges before final save
+    if !loadedRanges.isEmpty {
+        loadedRanges.sort { $0.0 < $1.0 }
+        var merged: [(Int, Int)] = []
+        for range in loadedRanges {
+            if let last = merged.last, last.1 + 1 >= range.0 {
+                merged[merged.count - 1] = (last.0, max(last.1, range.1))
+            } else {
+                merged.append(range)
+            }
+        }
+        loadedRanges = merged
+    }
+    // Final save
+    let mediaInfo = MediaInfo(expectedContentLength: expectedLength, mimeType: mimeType, supportsByteRangeAccess: supportsByteRangeAccess, headerFields: headerFields, savePath: mediaInfoPath)
+    mediaInfo.setLoadedDataRanges(loadedRanges)
+    mediaInfo.saveToFile()
+    let cacheSize = VideoCacheManager.shared.getCacheDirectorySize()
+    print("[expo-video] Final cache size: \(cacheSize) bytes")
+    print("[expo-video] MediaInfo debug: path=\(mediaInfoPath), loadedDataRanges=\(loadedRanges), expectedLength=\(expectedLength)")
+    return false
+  }
+}
+
+private extension UserDefaults {
+  func exists(forKey key: String) -> Bool {
+    return Self.standard.object(forKey: key) != nil
+  }
+
+  func maybeInteger(forKey key: String) -> Int? {
+    Self.standard.exists(forKey: key) ? Self.standard.integer(forKey: key) : nil
+  }
+}

package/ios/ContentKeyDelegate.swift

@@ -0,0 +1,214 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import AVFoundation
+import ExpoModulesCore
+
+internal class ContentKeyDelegate: NSObject, AVContentKeySessionDelegate {
+  // Video source that is currently being loaded. Used for retrieving information like license and certificate urls
+  var videoSource: VideoSource?
+
+  // MARK: - AVContentKeySessionDelegate
+
+  func contentKeySession(_ session: AVContentKeySession, didProvide keyRequest: AVContentKeyRequest) {
+    handleStreamingContentKeyRequest(keyRequest: keyRequest)
+  }
+
+  func contentKeySession(_ session: AVContentKeySession, didProvideRenewingContentKeyRequest keyRequest: AVContentKeyRequest) {
+    handleStreamingContentKeyRequest(keyRequest: keyRequest)
+  }
+
+  func contentKeySession(
+    _ session: AVContentKeySession,
+    shouldRetry keyRequest: AVContentKeyRequest,
+    reason retryReason: AVContentKeyRequest.RetryReason
+  ) -> Bool {
+    var shouldRetry = false
+
+    switch retryReason {
+    case AVContentKeyRequest.RetryReason.timedOut:
+      shouldRetry = true
+    case AVContentKeyRequest.RetryReason.receivedResponseWithExpiredLease:
+      shouldRetry = true
+    case AVContentKeyRequest.RetryReason.receivedObsoleteContentKey:
+      shouldRetry = true
+    default:
+      break
+    }
+
+    return shouldRetry
+  }
+
+  func contentKeySession(_ session: AVContentKeySession, contentKeyRequest keyRequest: AVContentKeyRequest, didFailWithError err: Error) {
+    log.error(err)
+  }
+
+  // MARK: - Private
+
+  func handleStreamingContentKeyRequest(keyRequest: AVContentKeyRequest) {
+    do {
+      try provideOnlineKey(keyRequest: keyRequest)
+    } catch {
+      keyRequest.processContentKeyResponseError(error)
+    }
+  }
+
+  private func provideOnlineKey(keyRequest: AVContentKeyRequest) throws {
+    guard
+      let assetIdString = findAssetIdString(keyRequest: keyRequest, videoSource: videoSource),
+      let assetIdData = assetIdString.data(using: .utf8)
+    else {
+      throw DRMLoadException("Failed to find the asset id for request: \(String(describing: keyRequest.identifier))")
+    }
+
+    let applicationCertificate = try self.requestApplicationCertificate(keyRequest: keyRequest)
+
+    let completionHandler = { [weak self] (spcData: Data?, error: Error?) in
+      guard let self else {
+        keyRequest.processContentKeyResponseError(DRMLoadException("Couldn't find a reference to the key delegate in the online key completion handler."))
+        return
+      }
+
+      if let error {
+        keyRequest.processContentKeyResponseError(error)
+        return
+      }
+
+      guard let spcData else {
+        return
+      }
+
+      do {
+        let ckcData = try self.requestContentKeyFromKeySecurityModule(spcData: spcData, assetID: assetIdString, keyRequest: keyRequest)
+        let keyResponse = AVContentKeyResponse(fairPlayStreamingKeyResponseData: ckcData)
+        keyRequest.processContentKeyResponse(keyResponse)
+      } catch {
+        keyRequest.processContentKeyResponseError(error)
+      }
+    }
+
+    keyRequest.makeStreamingContentKeyRequestData(
+      forApp: applicationCertificate,
+      contentIdentifier: assetIdData,
+      options: [AVContentKeyRequestProtocolVersionsKey: [1]],
+      completionHandler: completionHandler
+    )
+  }
+
+  private func requestApplicationCertificate(keyRequest: AVContentKeyRequest) throws -> Data {
+    if let certificateData = videoSource?.drm?.base64CertificateData {
+      return try requestCertificateFrom(base64String: certificateData)
+    }
+
+    guard let url = videoSource?.drm?.certificateUrl else {
+      throw DRMLoadException("The certificate uri and data are null")
+    }
+    return try requestCertificateFrom(url: url)
+  }
+
+  private func requestCertificateFrom(url: URL) throws -> Data {
+    let urlRequest = URLRequest(url: url)
+    let (data, response, error) = URLSession.shared.synchronousDataTask(with: urlRequest)
+
+    guard error == nil else {
+      let errorDescription = error?.localizedDescription ?? "unknown error"
+      throw DRMLoadException("Failed to load the application certificate from \(url.absoluteString): \(errorDescription)")
+    }
+
+    if let httpResponse = response as? HTTPURLResponse {
+      guard httpResponse.statusCode == 200 else {
+        throw DRMLoadException("Fetching the application certificate failed with status: \(httpResponse.statusCode)")
+      }
+    }
+    guard let data else {
+      throw DRMLoadException("Application certificate data received from \(url.absoluteString) is empty")
+    }
+
+    guard SecCertificateCreateWithData(nil, data as CFData) != nil else {
+      throw DRMLoadException("The application certificate received from the server is invalid")
+    }
+
+    return data
+  }
+
+  private func requestCertificateFrom(base64String: String) throws -> Data {
+    guard let certificateData = Data(base64Encoded: base64String, options: .ignoreUnknownCharacters) else {
+      throw DRMLoadException("Failed to load the application certificate from the provided base64 string")
+    }
+    return certificateData
+  }
+
+  private func requestContentKeyFromKeySecurityModule(spcData: Data, assetID: String, keyRequest: AVContentKeyRequest) throws -> Data {
+    let ckcData: Data? = nil
+
+    guard let licenseServerUri = videoSource?.drm?.licenseServer else {
+      throw DRMLoadException("LicenseServer uri hasn't been provided")
+    }
+    guard let licenseServerUrl = URL(string: licenseServerUri) else {
+      throw DRMLoadException("LicenseServer uri is invalid")
+    }
+
+    var ckcRequest = URLRequest(url: licenseServerUrl)
+    ckcRequest.httpMethod = "POST"
+    ckcRequest.httpBody = spcData
+
+    if let headers = videoSource?.drm?.headers {
+      for item in headers {
+        guard let value = item.value as? String else {
+          continue
+        }
+        ckcRequest.setValue(value, forHTTPHeaderField: item.key)
+      }
+    }
+
+    let (data, response, error) = URLSession.shared.synchronousDataTask(with: ckcRequest)
+
+    guard error == nil else {
+      throw DRMLoadException("Fetching the content key has failed with error: \(String(describing: error?.localizedDescription))")
+    }
+
+    if let httpResponse = response as? HTTPURLResponse {
+      guard httpResponse.statusCode == 200 else {
+        throw DRMLoadException("Fetching the content key has failed with status: \(httpResponse.statusCode)")
+      }
+    }
+    guard let data else {
+      throw DRMLoadException("Fetched content key data is empty")
+    }
+    return data
+  }
+
+  private func findAssetIdString(keyRequest: AVContentKeyRequest) -> String? {
+    let url = keyRequest.identifier as? String
+    return url?.replacingOccurrences(of: "skd://", with: "")
+  }
+
+  private func findAssetIdString(keyRequest: AVContentKeyRequest, videoSource: VideoSource?) -> String? {
+    return videoSource?.drm?.contentId ?? findAssetIdString(keyRequest: keyRequest)
+  }
+}
+
+// MARK: - Utils
+
+// https://stackoverflow.com/questions/26784315/can-i-somehow-do-a-synchronous-http-request-via-nsurlsession-in-swift
+private extension URLSession {
+  func synchronousDataTask(with urlRequest: URLRequest) -> (data: Data?, response: URLResponse?, error: Error?) {
+    var data: Data?
+    var response: URLResponse?
+    var error: Error?
+
+    let semaphore = DispatchSemaphore(value: 0)
+
+    let dataTask = self.dataTask(with: urlRequest) {
+      data = $0
+      response = $1
+      error = $2
+
+      semaphore.signal()
+    }
+    dataTask.resume()
+
+    _ = semaphore.wait(timeout: .distantFuture)
+
+    return (data, response, error)
+  }
+}

package/ios/ContentKeyManager.swift

@@ -0,0 +1,21 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import AVFoundation
+
+internal class ContentKeyManager {
+  static let contentKeyDelegateQueue = DispatchQueue(label: "dev.expo.video.ExpoVideo.ContentKeyDelegateQueue")
+  let contentKeySession: AVContentKeySession
+  let contentKeyDelegate: ContentKeyDelegate
+
+  init() {
+    contentKeySession = AVContentKeySession(keySystem: .fairPlayStreaming)
+    contentKeyDelegate = ContentKeyDelegate()
+
+    contentKeySession.setDelegate(contentKeyDelegate, queue: ContentKeyManager.contentKeyDelegateQueue)
+  }
+
+  func addContentKeyRequest(videoSource: VideoSource, asset: AVContentKeyRecipient) {
+    contentKeyDelegate.videoSource = videoSource
+    contentKeySession.addContentKeyRecipient(asset)
+  }
+}

package/ios/Enums/AudioMixingMode.swift

@@ -0,0 +1,37 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import CoreMedia
+
+internal enum AudioMixingMode: String, Enumerable {
+  case mixWithOthers
+  case duckOthers
+  case doNotMix
+  case auto
+
+  func priority() -> Int {
+    switch self {
+    case .doNotMix:
+      return 3
+    case .auto:
+      return 2
+    case .duckOthers:
+      return 1
+    case .mixWithOthers:
+      return 0
+    }
+  }
+
+  func toSessionCategoryOption() -> AVAudioSession.CategoryOptions? {
+    switch self {
+    case .duckOthers:
+      return .duckOthers
+    case .mixWithOthers:
+      return .mixWithOthers
+    case .doNotMix:
+      return nil
+    case .auto:
+      return nil
+    }
+  }
+}

package/ios/Enums/ContentType.swift

@@ -0,0 +1,12 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import CoreMedia
+
+internal enum ContentType: String, Enumerable {
+  case auto
+  case progressive
+  case hls
+  case dash
+  case smoothStreaming
+}

package/ios/Enums/DRMType.swift

@@ -0,0 +1,20 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+internal enum DRMType: String, Enumerable {
+  case clearkey
+  case fairplay
+  case playready
+  case widevine
+
+  func isSupported() -> Bool {
+    return self == .fairplay
+  }
+
+  internal func assertIsSupported() throws {
+    if !isSupported() {
+      throw DRMUnsupportedException(self)
+    }
+  }
+}

package/ios/Enums/PlayerStatus.swift

@@ -0,0 +1,10 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+internal enum PlayerStatus: String, Enumerable {
+  case idle
+  case loading
+  case readyToPlay
+  case error
+}

package/ios/Enums/VideoContentFit.swift

@@ -0,0 +1,39 @@
+import ExpoModulesCore
+
+internal enum VideoContentFit: String, Enumerable {
+  /**
+   The video is scaled to maintain its aspect ratio while fitting within the container's box.
+   The entire video is made to fill the box, while preserving its aspect ratio,
+   so the video will be "letterboxed" if its aspect ratio does not match the aspect ratio of the box.
+   */
+  case contain
+
+  /**
+   The video is sized to maintain its aspect ratio while filling the element's entire content box.
+   If the video's aspect ratio does not match the aspect ratio of its box, then the object will be clipped to fit.
+   */
+  case cover
+
+  /**
+   The video is sized to fill the element's content box. The entire object will completely fill the box.
+   If the video's aspect ratio does not match the aspect ratio of its box, then the video will be stretched to fit.
+   */
+  case fill
+
+  // TODO: Add `none` and `scaleDown`
+
+  /**
+   `VideoContentFit` cases can be directly translated to the native `AVLayerVideoGravity`
+   except `scaleDown` that needs to be handled differently at the later step of rendering.
+   */
+  func toVideoGravity() -> AVLayerVideoGravity {
+    switch self {
+    case .contain:
+      return .resizeAspect
+    case .cover:
+      return .resizeAspectFill
+    case .fill:
+      return .resize
+    }
+  }
+}