@stepincto/expo-video 1.0.0

package/ios/Thumbnails/VideoThumbnail.swift

@@ -0,0 +1,27 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import CoreImage
+import CoreGraphics
+import ExpoModulesCore
+
+internal final class VideoThumbnail: SharedRef<UIImage> {
+  internal override var nativeRefType: String {
+    "image"
+  }
+
+  var requestedTime: CMTime
+  var actualTime: CMTime
+
+  internal init(_ image: CGImage, requestedTime: CMTime, actualTime: CMTime) {
+    self.requestedTime = requestedTime
+    self.actualTime = actualTime
+    super.init(UIImage(cgImage: image))
+  }
+
+  override func getAdditionalMemoryPressure() -> Int {
+    guard let cgImage = ref.cgImage else {
+      return 0
+    }
+    return cgImage.bytesPerRow * cgImage.height
+  }
+}

package/ios/Thumbnails/VideoThumbnailGenerator.swift

@@ -0,0 +1,68 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import AVFoundation
+import CoreMedia
+
+/**
+ Generates an array of thumbnails from the given assets and options.
+ */
+internal func generateThumbnails(asset: AVAsset, times: [CMTime], options: VideoThumbnailOptions?) async throws -> [VideoThumbnail] {
+  let generator = AVAssetImageGenerator(asset: asset)
+
+  generator.appliesPreferredTrackTransform = true
+  generator.requestedTimeToleranceAfter = .zero
+  generator.maximumSize = options?.getMaxSize() ?? .zero
+
+  // `requestedTimeToleranceBefore` can only be set if times are less
+  // than the video duration, otherwise it will fail to generate an image.
+  if times.allSatisfy({ $0 < asset.duration }) {
+    generator.requestedTimeToleranceBefore = .zero
+  }
+  return try await generateThumbnails(generator: generator, times: times)
+}
+
+/**
+ Generates an array of thumbnails using the given image generator. It uses two different ways to generate the images, based on the platform version.
+ */
+private func generateThumbnails(generator: AVAssetImageGenerator, times: [CMTime]) async throws -> [VideoThumbnail] {
+  if #available(iOS 16, tvOS 16, *) {
+    return try await generator
+      .images(for: times)
+      .reduce(into: [VideoThumbnail]()) { thumbnails, result in
+        let thumbnail = try VideoThumbnail(result.image, requestedTime: result.requestedTime, actualTime: result.actualTime)
+        thumbnails.append(thumbnail)
+      }
+  }
+  return try await VideoThumbnailLegacyGenerator(generator: generator, times: times)
+    .reduce(into: [VideoThumbnail]()) { thumbnails, thumbnail in
+      thumbnails.append(thumbnail)
+    }
+}
+
+/**
+ A replacement for the `AVAssetImageGenerator.images(for:)` async iterator that is available only as of iOS 16.
+ */
+internal struct VideoThumbnailLegacyGenerator: AsyncSequence, AsyncIteratorProtocol {
+  typealias Element = VideoThumbnail
+
+  let generator: AVAssetImageGenerator
+  let times: [CMTime]
+  var currentIndex: Int = 0
+
+  mutating func next() async throws -> Element? {
+    guard currentIndex < times.count, !Task.isCancelled else {
+      return nil
+    }
+    let requestedTime = times[currentIndex]
+    var actualTime = CMTime.zero
+    let image = try generator.copyCGImage(at: requestedTime, actualTime: &actualTime)
+
+    currentIndex += 1
+
+    return VideoThumbnail(image, requestedTime: requestedTime, actualTime: actualTime)
+  }
+
+  func makeAsyncIterator() -> Self {
+    return self
+  }
+}

package/ios/Thumbnails/VideoThumbnailOptions.swift

@@ -0,0 +1,15 @@
+import ExpoModulesCore
+
+/**
+ Record representing thumbnail generation options.
+ */
+internal struct VideoThumbnailOptions: Record {
+  static let `default` = VideoThumbnailOptions()
+
+  @Field var maxWidth: Int = 0
+  @Field var maxHeight: Int = 0
+
+  func getMaxSize() -> CGSize {
+    return CGSize(width: maxWidth, height: maxHeight)
+  }
+}

package/ios/VideoAsset.swift

@@ -0,0 +1,123 @@
+import Foundation
+import AVFoundation
+import CryptoKit
+import MobileCoreServices
+import ExpoModulesCore
+
+internal class VideoAsset: AVURLAsset, @unchecked Sendable {
+  internal let videoSource: VideoSource
+  private var resourceLoaderDelegate: ResourceLoaderDelegate?
+  private let initialScheme: String?
+  private let saveFilePath: String?
+  private var customFileExtension: String?
+  private let useCaching: Bool
+
+  var cachingError: Error?
+
+  internal var urlRequestHeaders: [String: String]?
+
+  init(url: URL, videoSource: VideoSource) {
+    self.videoSource = videoSource
+    let cachedMimeType = MediaInfo(forResourceUrl: url)?.mimeType
+    let cachedExtension = mimeTypeToExtension(mimeType: cachedMimeType) ?? ""
+    let fileExtension = url.pathExtension.isEmpty ? cachedExtension : url.pathExtension
+    self.saveFilePath = Self.pathForUrl(url: url, fileExtension: fileExtension)
+    self.urlRequestHeaders = videoSource.headers
+    self.initialScheme = URLComponents(url: url, resolvingAgainstBaseURL: false)?.scheme
+
+    // Creates an URL that will delegate it's requests to ResourceLoaderDelegate
+    let urlWithCustomScheme = url.withScheme(VideoCacheManager.expoVideoCacheScheme)
+
+    let assetOptions: [String: Any]? = if let headers = videoSource.headers {
+      ["AVURLAssetHTTPHeaderFieldsKey": headers]
+    } else {
+      nil
+    }
+
+    let canCache = Self.canCache(videoSource: videoSource)
+
+    if saveFilePath == nil && videoSource.useCaching {
+      log.warn("Failed to create a cache file path for the provided source with uri: \(videoSource.uri?.absoluteString ?? "null")")
+    }
+
+    if !canCache && videoSource.useCaching {
+      log.warn("Provided source with uri: \(videoSource.uri?.absoluteString ?? "null") cannot be cached. Caching will be disabled")
+    }
+
+    if urlWithCustomScheme == nil && videoSource.useCaching {
+      log.warn("CachingPlayerItem error: Urls without a scheme are not supported, the resource won't be cached")
+    }
+
+    guard let saveFilePath, let urlWithCustomScheme, videoSource.useCaching else {
+      // Initialize with no caching
+      useCaching = false
+      super.init(url: url, options: assetOptions)
+      return
+    }
+
+    // Enable caching
+    useCaching = true
+    resourceLoaderDelegate = ResourceLoaderDelegate(url: url, saveFilePath: saveFilePath, fileExtension: fileExtension, urlRequestHeaders: urlRequestHeaders)
+    super.init(url: urlWithCustomScheme, options: assetOptions)
+
+    resourceLoaderDelegate?.onError = { [weak self] error in
+      self?.cachingError = error
+    }
+    self.resourceLoader.setDelegate(resourceLoaderDelegate, queue: VideoCacheManager.shared.cacheQueue)
+    self.createCacheDirectoryIfNeeded()
+    VideoCacheManager.shared.ensureCacheIntegrity(forSavePath: saveFilePath)
+  }
+
+  deinit {
+    guard useCaching else {
+      return
+    }
+    if let saveFilePath, let cachedFileUrl = URL(string: saveFilePath) {
+      VideoCacheManager.shared.unregisterOpenFile(at: cachedFileUrl)
+    }
+    VideoCacheManager.shared.ensureCacheSize()
+  }
+
+  static func pathForUrl(url: URL, fileExtension: String) -> String? {
+    let hashedData = SHA256.hash(data: Data(url.absoluteString.utf8))
+    let hashString = hashedData.compactMap { String(format: "%02x", $0) }.joined()
+    let parsedExtension = fileExtension.starts(with: ".") || fileExtension.isEmpty ? fileExtension : ("." + fileExtension)
+    let hashFilename = hashString + parsedExtension
+
+    guard var cachesDirectory = try? FileManager.default.url(
+      for: .cachesDirectory,
+      in: .userDomainMask,
+      appropriateFor: nil,
+      create: true)
+    else {
+      log.warn("CachingPlayerItem error: Can't access default cache directory")
+      return nil
+    }
+
+    cachesDirectory.appendPathComponent(VideoCacheManager.expoVideoCacheScheme, isDirectory: true)
+    cachesDirectory.appendPathComponent(hashFilename)
+
+    return cachesDirectory.path
+  }
+
+  static func canCache(videoSource: VideoSource) -> Bool {
+    guard videoSource.uri?.scheme?.starts(with: "http") == true else {
+      return false
+    }
+    return videoSource.drm == nil
+  }
+
+  private func createCacheDirectoryIfNeeded() {
+    guard var cachesDirectory = try? FileManager.default.url(
+      for: .cachesDirectory,
+      in: .userDomainMask,
+      appropriateFor: nil,
+      create: true)
+    else {
+      return
+    }
+
+    cachesDirectory.appendPathComponent(VideoCacheManager.expoVideoCacheScheme, isDirectory: true)
+    try? FileManager.default.createDirectory(at: cachesDirectory, withIntermediateDirectories: true)
+  }
+}

package/ios/VideoExceptions.swift

@@ -0,0 +1,53 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+private let defaultCause = "unknown cause"
+
+internal final class PictureInPictureUnsupportedException: Exception {
+  override var reason: String {
+    "Picture in picture is not supported on this device"
+  }
+}
+
+internal final class DRMUnsupportedException: GenericException<DRMType> {
+  override var reason: String {
+    "DRMType: `\(param)` is unsupported on iOS"
+  }
+}
+
+internal final class DRMLoadException: GenericException<String?> {
+  override var reason: String {
+    "Failed to decrypt the video stream: \(param ?? defaultCause)"
+  }
+}
+
+internal final class PlayerException: GenericException<String?> {
+  override var reason: String {
+    "Failed to initialise the player: \(param ?? defaultCause)"
+  }
+}
+
+internal final class PlayerItemLoadException: GenericException<String?> {
+  override var reason: String {
+    "Failed to load the player item: \(param ?? defaultCause)"
+  }
+}
+
+internal final class CachingAssetInitializationException: GenericException<URL?> {
+  override var reason: String {
+    "Failed to initialize a caching asset. The provided url: \(param?.absoluteString ?? "nil") doesn't have a valid scheme for caching"
+  }
+}
+
+internal final class VideoCacheException: GenericException<String?> {
+  override var reason: String {
+    param ?? "Unexpected expo-video cache error"
+  }
+}
+
+internal final class VideoCacheUnsupportedFormatException: GenericException<String> {
+  override var reason: String {
+    "The server responded with a resource with mimeType: \(param) which cannot be played with caching enabled"
+  }
+}

package/ios/VideoItem.swift

@@ -0,0 +1,11 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+internal final class VideoItem: SharedObject {
+  let playerItem: AVPlayerItem
+
+  init(url: URL) {
+    playerItem = AVPlayerItem(url: url)
+  }
+}

package/ios/VideoManager.swift

@@ -0,0 +1,140 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import AVKit
+import Foundation
+import ExpoModulesCore
+
+/**
+ * Helper class used to keep track of all existing VideoViews and VideoPlayers and manage their lifecycle
+ */
+class VideoManager {
+  static var shared = VideoManager()
+
+  private static var managerQueue = DispatchQueue(label: "com.expo.video.manager.managerQueue")
+  private var videoViews = NSHashTable<VideoView>.weakObjects()
+  private var videoPlayers = NSHashTable<VideoPlayer>.weakObjects()
+
+  var hasRegisteredPlayers: Bool {
+    return !videoPlayers.allObjects.isEmpty
+  }
+
+  func register(videoPlayer: VideoPlayer) {
+    Self.managerQueue.async { [weak self, weak videoPlayer] in
+      guard let self = self, let videoPlayer = videoPlayer else {
+        return
+      }
+      self.videoPlayers.add(videoPlayer)
+    }
+  }
+
+  func unregister(videoPlayer: VideoPlayer) {
+    Self.managerQueue.async { [weak self, weak videoPlayer] in
+      guard let self = self, let videoPlayer = videoPlayer else {
+        return
+      }
+      self.videoPlayers.remove(videoPlayer)
+    }
+  }
+
+  func register(videoView: VideoView) {
+    videoViews.add(videoView)
+  }
+
+  func unregister(videoView: VideoView) {
+    videoViews.remove(videoView)
+  }
+
+  func onAppForegrounded() {
+    for videoPlayer in videoPlayers.allObjects {
+      videoPlayer.setTracksEnabled(true)
+    }
+  }
+
+  func onAppBackgrounded() {
+    for videoView in videoViews.allObjects {
+      guard let player = videoView.player else {
+        continue
+      }
+      if player.staysActiveInBackground == true {
+        player.setTracksEnabled(videoView.isInPictureInPicture)
+      } else if !videoView.isInPictureInPicture {
+        player.ref.pause()
+      }
+    }
+  }
+
+  // MARK: - Audio Session Management
+
+  // This function usually takes less than 5ms to execute, but in some cases (initial setup) it takes up to 70ms
+  // Because of this we dispatch it on another queue to minimize the load on main queue.
+  internal func setAppropriateAudioSessionOrWarn() {
+    Self.managerQueue.async { [weak self] in
+      self?.setAudioSession()
+    }
+  }
+
+  private func setAudioSession() {
+    let audioSession = AVAudioSession.sharedInstance()
+    let audioMixingMode = findAudioMixingMode()
+    var audioSessionCategoryOptions: AVAudioSession.CategoryOptions = audioSession.categoryOptions
+
+    let isOutputtingAudio = videoPlayers.allObjects.contains { player in
+      player.isPlaying && !player.isMuted
+    }
+    let anyPlayerShowsNotification = videoPlayers.allObjects.contains { player in
+      player.showNowPlayingNotification
+    }
+
+    let shouldMixOverride = audioMixingMode == .mixWithOthers
+    let doNotMixOverride = audioMixingMode == .doNotMix
+    let shouldDuckOthers = audioMixingMode == .duckOthers && isOutputtingAudio
+
+    // The now playing notification won't be shown if we allow the audio to mix with others
+    let autoShouldMix = !isOutputtingAudio && !anyPlayerShowsNotification
+    let shouldMixWithOthers = shouldMixOverride || autoShouldMix
+
+    if shouldMixWithOthers && !shouldDuckOthers && !doNotMixOverride {
+      audioSessionCategoryOptions.insert(.mixWithOthers)
+    } else {
+      audioSessionCategoryOptions.remove(.mixWithOthers)
+    }
+
+    if shouldDuckOthers && !doNotMixOverride {
+      audioSessionCategoryOptions.insert(.duckOthers)
+    } else {
+      audioSessionCategoryOptions.remove(.duckOthers)
+    }
+
+    if audioSession.categoryOptions != audioSessionCategoryOptions || audioSession.category != .playback || audioSession.mode != .moviePlayback {
+      do {
+        try audioSession.setCategory(.playback, mode: .moviePlayback, options: audioSessionCategoryOptions)
+      } catch {
+        log.warn("Failed to set audio session category. This might cause issues with audio playback and Picture in Picture. \(error.localizedDescription)")
+      }
+    }
+
+    // Make sure audio session is active if any video is playing
+    if isOutputtingAudio || doNotMixOverride {
+      do {
+        try audioSession.setActive(true)
+      } catch {
+        log.warn("Failed to activate the audio session. This might cause issues with audio playback. \(error.localizedDescription)")
+      }
+    }
+  }
+
+  private func findAudioMixingMode() -> AudioMixingMode? {
+    let playingPlayers = videoPlayers.allObjects.filter({ player in
+      player.isPlaying
+    })
+    var audioMixingMode: AudioMixingMode = .mixWithOthers
+
+    if playingPlayers.isEmpty {
+      return nil
+    }
+    for videoPlayer in playingPlayers where (audioMixingMode.priority()) < videoPlayer.audioMixingMode.priority() {
+      audioMixingMode = videoPlayer.audioMixingMode
+    }
+    return audioMixingMode
+  }
+}