spactureai-mobile-player 1.0.30

package/ios/core/VideoError.swift

@@ -0,0 +1,164 @@
+//
+//  VideoFileHelper.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 24/01/2025.
+//
+
+import Foundation
+import NitroModules
+
+// MARK: - LibraryError
+enum LibraryError: VideoError {
+  case deallocated(objectName: String)
+
+  var code: String {
+    switch self {
+    case .deallocated:
+      return "library/deallocated"
+    }
+  }
+
+  var message: String {
+    switch self {
+    case let .deallocated(objectName: objectName):
+      return "Object \(objectName) has been deallocated"
+    }
+  }
+}
+
+// MARK: - PlayerError
+enum PlayerError: VideoError {
+  case notInitialized
+  case assetNotInitialized
+  case invalidSource
+  case invalidTrackUrl(url: String)
+  case cancelled
+  
+  var code: String {
+    switch self {
+    case .notInitialized:
+      return "player/not-initialized"
+    case .assetNotInitialized:
+      return "player/asset-not-initialized"
+    case .invalidSource:
+      return "player/invalid-source"
+    case .invalidTrackUrl:
+      return "player/invalid-track-url"
+    case .cancelled:
+      return "player/cancelled"
+    }
+  }
+  
+  var message: String {
+    switch self {
+    case .notInitialized:
+      return "Player has not been initialized (Or has been set to nil)"
+    case .assetNotInitialized:
+      return "Asset has not been initialized (Or has been set to nil)"
+    case .invalidSource:
+      return "Invalid source passed to player"
+    case let .invalidTrackUrl(url: url):
+      return "Invalid track URL: \(url)"
+    case .cancelled:
+      return "Operation was cancelled"
+    }
+  }
+}
+
+// MARK: - SourceError
+enum SourceError: VideoError {
+  case invalidUri(uri: String)
+  case missingReadFilePermission(uri: String)
+  case fileDoesNotExist(uri: String)
+  case failedToInitializeAsset
+  case unsupportedContentType(uri: String)
+  case cancelled
+
+  var code: String {
+    switch self {
+    case .invalidUri:
+      return "source/invalid-uri"
+    case .missingReadFilePermission:
+      return "source/missing-read-file-permission"
+    case .fileDoesNotExist:
+      return "source/file-does-not-exist"
+    case .failedToInitializeAsset:
+      return "source/failed-to-initialize-asset"
+    case .unsupportedContentType:
+      return "source/unsupported-content-type"
+    case .cancelled:
+      return "source/cancelled"
+    }
+  }
+
+  var message: String {
+    switch self {
+    case let .invalidUri(uri: uri):
+      return "Invalid source file uri: \(uri)"
+    case let .missingReadFilePermission(uri: uri):
+      return "Missing read file permission for source file at \(uri)"
+    case let .fileDoesNotExist(uri: uri):
+      return "File does not exist at URI: \(uri)"
+    case .failedToInitializeAsset:
+      return "Failed to initialize asset"
+    case let .unsupportedContentType(uri: uri):
+      return "type of content (\(uri)) is not supported"
+    case .cancelled:
+      return "Operation was cancelled"
+    }
+  }
+}
+
+// MARK: - VideoViewError
+enum VideoViewError: VideoError {
+  case viewNotFound(nitroId: Double)
+  case viewIsDeallocated
+  case pictureInPictureNotSupported
+  
+  var code: String {
+    switch self {
+    case .viewNotFound:
+      return "view/not-found"
+    case .viewIsDeallocated:
+      return "view/deallocated"
+    case .pictureInPictureNotSupported:
+      return "view/picture-in-picture-not-supported"
+    }
+  }
+  
+  var message: String {
+    switch self {
+    case let .viewNotFound(nitroId: nitroId):
+      return "View with nitroId \(nitroId) not found"
+    case .viewIsDeallocated:
+      return "Attempt to access a view, but it has been deallocated (or not initialized)"
+    case .pictureInPictureNotSupported:
+      return "Picture in picture is not supported on this device"
+    }
+  }
+}
+
+// MARK: - UnknownError
+struct UnknownError: VideoError {
+  var code: String { "unknown/unknown" }
+  var message: String { "Unknown error" }
+}
+
+// MARK: - VideoError
+protocol VideoError {
+  var code: String { get }
+  var message: String { get }
+}
+
+extension VideoError {
+  private func getMessage() -> String {
+    return "{%@\(code)::\(message)@%}"
+  }
+
+  func error() -> Error {
+    return RuntimeError.error(withMessage: getMessage())
+  }
+}
+
+

package/ios/core/VideoManager.swift

@@ -0,0 +1,219 @@
+//
+//  VideoManager.swift
+//  ReactNativeVideo
+//
+//  VLC backend rewrite — keeps a registry of live players/views and a
+//  minimal AVAudioSession configuration so audio routes correctly. All
+//  AVPlayer-specific logic (external playback, NowPlaying integration,
+//  audiovisualBackgroundPlaybackPolicy, etc.) was removed.
+//
+
+import AVFoundation
+import Foundation
+import UIKit
+
+class VideoManager {
+  static let shared = VideoManager()
+
+  private var players = NSHashTable<HybridVideoPlayer>.weakObjects()
+  private var videoView = NSHashTable<VideoComponentView>.weakObjects()
+
+  private var isAudioSessionActive = false
+  private var isAudioSessionManagementDisabled: Bool = false
+
+  private init() {
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(handleAudioSessionInterruption),
+      name: AVAudioSession.interruptionNotification,
+      object: nil
+    )
+
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(applicationWillResignActive(notification:)),
+      name: UIApplication.willResignActiveNotification,
+      object: nil
+    )
+
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(applicationDidBecomeActive(notification:)),
+      name: UIApplication.didBecomeActiveNotification,
+      object: nil
+    )
+
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(applicationDidEnterBackground(notification:)),
+      name: UIApplication.didEnterBackgroundNotification,
+      object: nil
+    )
+
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(applicationWillEnterForeground(notification:)),
+      name: UIApplication.willEnterForegroundNotification,
+      object: nil
+    )
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+
+  func register(player: HybridVideoPlayer) {
+    players.add(player)
+  }
+
+  func unregister(player: HybridVideoPlayer) {
+    players.remove(player)
+  }
+
+  func register(view: VideoComponentView) {
+    videoView.add(view)
+  }
+
+  func unregister(view: VideoComponentView) {
+    videoView.remove(view)
+  }
+
+  func requestAudioSessionUpdate() {
+    updateAudioSessionConfiguration()
+  }
+
+  // MARK: - Audio Session Management
+
+  private func activateAudioSession() {
+    if isAudioSessionActive { return }
+    do {
+      try AVAudioSession.sharedInstance().setActive(true)
+      isAudioSessionActive = true
+    } catch {
+      print("UnifiedPlayer: Failed to activate audio session: \(error.localizedDescription)")
+    }
+  }
+
+  private func deactivateAudioSession() {
+    if !isAudioSessionActive { return }
+    do {
+      try AVAudioSession.sharedInstance().setActive(
+        false, options: .notifyOthersOnDeactivation
+      )
+      isAudioSessionActive = false
+    } catch {
+      print("UnifiedPlayer: Failed to deactivate audio session: \(error.localizedDescription)")
+    }
+  }
+
+  private func updateAudioSessionConfiguration() {
+    if isAudioSessionManagementDisabled { return }
+
+    let isAnyPlayerPlaying = players.allObjects.contains { player in
+      !player.muted && player.isPlaying
+    }
+    let anyPlayerNeedsBackground = players.allObjects.contains { $0.playInBackground }
+
+    if isAnyPlayerPlaying || anyPlayerNeedsBackground {
+      activateAudioSession()
+    } else {
+      deactivateAudioSession()
+    }
+
+    configureAudioSession()
+  }
+
+  private func configureAudioSession() {
+    if isAudioSessionManagementDisabled { return }
+
+    let audioSession = AVAudioSession.sharedInstance()
+    var options: AVAudioSession.CategoryOptions = audioSession.categoryOptions
+
+    let anyPlayerNeedsObey = players.allObjects.contains { $0.ignoreSilentSwitchMode == .obey }
+
+    let mixingMode = determineAudioMixingMode()
+    switch mixingMode {
+    case .mixwithothers:
+      options.insert(.mixWithOthers)
+    case .donotmix:
+      options.remove(.mixWithOthers)
+    case .duckothers:
+      options.insert(.duckOthers)
+    case .auto:
+      options.remove(.mixWithOthers)
+      options.remove(.duckOthers)
+    }
+
+    let category: AVAudioSession.Category = anyPlayerNeedsObey ? .ambient : .playback
+
+    do {
+      try audioSession.setCategory(category, mode: .moviePlayback, options: options)
+    } catch {
+      print("UnifiedPlayer: Failed to set audio session category: \(error.localizedDescription)")
+    }
+  }
+
+  private func determineAudioMixingMode() -> MixAudioMode {
+    let active = players.allObjects.filter { $0.isPlaying && !$0.muted }
+    if active.isEmpty { return .mixwithothers }
+
+    if active.contains(where: { $0.mixAudioMode == .donotmix }) { return .donotmix }
+    if active.contains(where: { $0.mixAudioMode == .auto }) { return .auto }
+    if active.contains(where: { $0.mixAudioMode == .duckothers }) { return .duckothers }
+    return .mixwithothers
+  }
+
+  // MARK: - Notification handlers
+
+  @objc
+  private func handleAudioSessionInterruption(notification: Notification) {
+    guard let userInfo = notification.userInfo,
+      let typeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
+      let type = AVAudioSession.InterruptionType(rawValue: typeValue)
+    else { return }
+
+    switch type {
+    case .began:
+      break
+    case .ended:
+      if let optionsValue = userInfo[AVAudioSessionInterruptionOptionKey] as? UInt {
+        let resumeOptions = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
+        if resumeOptions.contains(.shouldResume) {
+          updateAudioSessionConfiguration()
+        }
+      }
+    @unknown default:
+      break
+    }
+  }
+
+  @objc func applicationWillResignActive(notification: Notification) {
+    for player in players.allObjects {
+      if player.playInBackground || player.playWhenInactive || !player.isPlaying { continue }
+      try? player.pause()
+      player.wasAutoPaused = true
+    }
+  }
+
+  @objc func applicationDidBecomeActive(notification: Notification) {
+    for player in players.allObjects where player.wasAutoPaused {
+      try? player.play()
+      player.wasAutoPaused = false
+    }
+  }
+
+  @objc func applicationDidEnterBackground(notification: Notification) {
+    for player in players.allObjects {
+      if player.playInBackground || !player.isPlaying { continue }
+      try? player.pause()
+      player.wasAutoPaused = true
+    }
+  }
+
+  @objc func applicationWillEnterForeground(notification: Notification) {
+    for player in players.allObjects where player.wasAutoPaused {
+      try? player.play()
+      player.wasAutoPaused = false
+    }
+  }
+}