@pigeonmal/react-native-video 7.0.0-beta.2

package/ios/hybrids/VideoViewViewManager/HybridVideoViewViewManager.swift

@@ -0,0 +1,266 @@
+//
+//  HybridVideoViewViewManager.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 23/09/2024.
+//
+
+import Foundation
+import AVKit
+import NitroModules
+
+struct ViewListenerPair {
+  let id: UUID
+  let eventName: String
+  let callback: Any
+}
+
+class HybridVideoViewViewManager: HybridVideoViewViewManagerSpec {
+  weak var view: VideoComponentView?
+  var listeners: [ViewListenerPair] = []
+  
+  let DEALOCATED_WARNING = "ReactNativeVideo: VideoComponentView is no longer available. It is likely that the view was deallocated."
+  
+  init(nitroId: Double) throws {
+    guard let view = VideoComponentView.globalViewsMap.object(forKey: NSNumber(value: nitroId)) else {
+      throw VideoViewError.viewNotFound(nitroId: nitroId).error()
+    }
+    
+    self.view = view
+    super.init()
+    view.delegate = VideoViewDelegate(viewManager: self)
+  }
+  
+  // MARK: - Private helpers
+  
+  private func addListener<T>(eventName: String, listener: T) -> ListenerSubscription {
+    let id = UUID()
+    listeners.append(ViewListenerPair(id: id, eventName: eventName, callback: listener))
+    return ListenerSubscription(remove: { [weak self] in
+      self?.listeners.removeAll { $0.id == id }
+    })
+  }
+  
+  private func emitEvent<T>(eventName: String, invoke: (T) throws -> Void) {
+    for pair in listeners where pair.eventName == eventName {
+      if let callback = pair.callback as? T {
+        do {
+          try invoke(callback)
+        } catch {
+          print("[ReactNativeVideo] Error calling \(eventName) listener: \(error)")
+        }
+      } else {
+        print("[ReactNativeVideo] Invalid callback type for \(eventName)")
+      }
+    }
+  }
+  
+  // MARK: - Properties
+  
+  weak var player: (any HybridVideoPlayerSpec)? {
+    get {
+      guard let view = view else {
+        print(DEALOCATED_WARNING)
+        return nil
+      }
+      return view.player
+    }
+    set {
+      guard let view = view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      view.player = newValue
+    }
+  }
+  
+  var controls: Bool {
+    get {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return false
+      }
+      
+      return view.controls
+    }
+    set {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      
+      view.controls = newValue
+    }
+  }
+  
+  var pictureInPicture: Bool {
+    get {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return false
+      }
+      
+      return view.allowsPictureInPicturePlayback
+    }
+    set {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      
+      view.allowsPictureInPicturePlayback = newValue
+    }
+  }
+  
+  var autoEnterPictureInPicture: Bool {
+    get {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return false
+      }
+      
+      return view.autoEnterPictureInPicture
+    }
+    set {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      
+      view.autoEnterPictureInPicture = newValue
+    }
+  }
+  
+  var resizeMode: ResizeMode {
+    get {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return .none
+      }
+      
+      return view.resizeMode
+    }
+    set {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      
+      view.resizeMode = newValue
+    }
+  }
+  
+  var keepScreenAwake: Bool {
+    get {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return false
+      }
+      
+      return view.keepScreenAwake
+    }
+    set {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      
+      view.keepScreenAwake = newValue
+    }
+  }
+  
+  // Android only - no-op on iOS
+  var surfaceType: SurfaceType = .surface
+  
+  func enterFullscreen() throws {
+    guard let view else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+    
+    try view.enterFullscreen()
+  }
+  
+  func exitFullscreen() throws {
+    guard let view else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+    
+    try view.exitFullscreen()
+  }
+  
+  func enterPictureInPicture() throws {
+    guard let view else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+    
+    try view.startPictureInPicture()
+  }
+  
+  func exitPictureInPicture() throws {
+    guard let view else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+    
+    try view.stopPictureInPicture()
+  }
+  
+  func canEnterPictureInPicture() -> Bool {
+    return AVPictureInPictureController.isPictureInPictureSupported()
+  }
+  
+  // MARK: - Listener registration methods
+  
+  func addOnPictureInPictureChangeListener(listener: @escaping (Bool) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onPictureInPictureChange", listener: listener)
+  }
+  
+  func addOnFullscreenChangeListener(listener: @escaping (Bool) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onFullscreenChange", listener: listener)
+  }
+  
+  func addWillEnterFullscreenListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "willEnterFullscreen", listener: listener)
+  }
+  
+  func addWillExitFullscreenListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "willExitFullscreen", listener: listener)
+  }
+  
+  func addWillEnterPictureInPictureListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "willEnterPictureInPicture", listener: listener)
+  }
+  
+  func addWillExitPictureInPictureListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "willExitPictureInPicture", listener: listener)
+  }
+  
+  func clearAllListeners() throws {
+    listeners.removeAll()
+  }
+  
+  // MARK: - Event emission methods
+  
+  func onPictureInPictureChange(_ isActive: Bool) {
+    emitEvent(eventName: "onPictureInPictureChange") { (callback: (Bool) throws -> Void) in try callback(isActive) }
+  }
+  
+  func onFullscreenChange(_ isActive: Bool) {
+    emitEvent(eventName: "onFullscreenChange") { (callback: (Bool) throws -> Void) in try callback(isActive) }
+  }
+  
+  func willEnterFullscreen() {
+    emitEvent(eventName: "willEnterFullscreen") { (callback: () throws -> Void) in try callback() }
+  }
+  
+  func willExitFullscreen() {
+    emitEvent(eventName: "willExitFullscreen") { (callback: () throws -> Void) in try callback() }
+  }
+  
+  func willEnterPictureInPicture() {
+    emitEvent(eventName: "willEnterPictureInPicture") { (callback: () throws -> Void) in try callback() }
+  }
+  
+  func willExitPictureInPicture() {
+    emitEvent(eventName: "willExitPictureInPicture") { (callback: () throws -> Void) in try callback() }
+  }
+}

package/ios/hybrids/VideoViewViewManager/HybridVideoViewViewManagerFactory.swift

@@ -0,0 +1,14 @@
+//
+//  HybridVideoViewViewManagerFactory.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 23/09/2024.
+//
+
+import Foundation
+
+class HybridVideoViewViewManagerFactory: HybridVideoViewViewManagerFactorySpec {
+  func createViewManager(nitroId: Double) throws -> any HybridVideoViewViewManagerSpec {
+    return try HybridVideoViewViewManager(nitroId: nitroId)
+  }
+}

package/ios/view/VideoComponentView.swift

@@ -0,0 +1,274 @@
+//
+//  VideoComponent.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 30/09/2024.
+//
+
+import AVFoundation
+import AVKit
+import Foundation
+import UIKit
+
+@objc public class VideoComponentView: UIView {
+  public weak var player: HybridVideoPlayerSpec? = nil {
+    didSet {
+      guard let player = player as? HybridVideoPlayer else { return }
+      configureAVPlayerViewController(with: player.player)
+    }
+  }
+
+  var delegate: VideoViewDelegate?
+  private var playerView: UIView? = nil
+
+  private var observer: VideoComponentViewObserver? {
+    didSet {
+      playerViewController?.delegate = observer
+      observer?.updatePlayerViewControllerObservers()
+    }
+  }
+
+  private var _keepScreenAwake: Bool = false
+  var keepScreenAwake: Bool {
+    get {
+      guard let player = player as? HybridVideoPlayer else { return false }
+      return player.player.preventsDisplaySleepDuringVideoPlayback
+    }
+    set {
+      guard let player = player as? HybridVideoPlayer else { return }
+      player.player.preventsDisplaySleepDuringVideoPlayback = newValue
+      _keepScreenAwake = newValue
+    }
+  }
+
+  var playerViewController: AVPlayerViewController? {
+    didSet {
+      guard let observer, let playerViewController else { return }
+      playerViewController.delegate = observer
+      observer.updatePlayerViewControllerObservers()
+    }
+  }
+
+  public var controls: Bool = false {
+    didSet {
+      DispatchQueue.main.async { [weak self] in
+        guard let self = self, let playerViewController = self.playerViewController else { return }
+        playerViewController.showsPlaybackControls = self.controls
+      }
+    }
+  }
+
+  public var allowsPictureInPicturePlayback: Bool = false {
+    didSet {
+      DispatchQueue.main.async { [weak self] in
+        guard let self = self, let playerViewController = self.playerViewController else { return }
+
+        VideoManager.shared.requestAudioSessionUpdate()
+        playerViewController.allowsPictureInPicturePlayback = self.allowsPictureInPicturePlayback
+      }
+    }
+  }
+
+  public var autoEnterPictureInPicture: Bool = false {
+    didSet {
+      DispatchQueue.main.async { [weak self] in
+        guard let self = self, let playerViewController = self.playerViewController else { return }
+
+        VideoManager.shared.requestAudioSessionUpdate()
+        playerViewController.canStartPictureInPictureAutomaticallyFromInline =
+          self.autoEnterPictureInPicture
+      }
+    }
+  }
+
+  public var resizeMode: ResizeMode = .none {
+    didSet {
+      DispatchQueue.main.async { [weak self] in
+        guard let self = self, let playerViewController = self.playerViewController else { return }
+        playerViewController.videoGravity = resizeMode.toVideoGravity()
+      }
+    }
+  }
+
+  @objc public var nitroId: NSNumber = -1 {
+    didSet {
+      VideoComponentView.globalViewsMap.setObject(self, forKey: nitroId)
+    }
+  }
+
+  @objc public static var globalViewsMap: NSMapTable<NSNumber, VideoComponentView> =
+    .strongToWeakObjects()
+
+  @objc public override init(frame: CGRect) {
+    super.init(frame: frame)
+    VideoManager.shared.register(view: self)
+    setupPlayerView()
+    observer = VideoComponentViewObserver(view: self)
+  }
+
+  deinit {
+    VideoManager.shared.unregister(view: self)
+  }
+
+  @objc public required init?(coder: NSCoder) {
+    super.init(coder: coder)
+    setupPlayerView()
+  }
+
+  func setNitroId(nitroId: NSNumber) {
+    self.nitroId = nitroId
+  }
+
+  private func setupPlayerView() {
+    // Create a UIView to hold the video player layer
+    playerView = UIView(frame: self.bounds)
+    playerView?.translatesAutoresizingMaskIntoConstraints = false
+    if let playerView = playerView {
+      addSubview(playerView)
+      NSLayoutConstraint.activate([
+        playerView.leadingAnchor.constraint(equalTo: self.leadingAnchor),
+        playerView.trailingAnchor.constraint(equalTo: self.trailingAnchor),
+        playerView.topAnchor.constraint(equalTo: self.topAnchor),
+        playerView.bottomAnchor.constraint(equalTo: self.bottomAnchor),
+      ])
+    }
+  }
+
+  public func configureAVPlayerViewController(with player: AVPlayer) {
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self, let playerView = self.playerView else { return }
+
+      // Skip reconfiguration if player hasn't changed and controller already exists
+      if let existingController = self.playerViewController,
+        existingController.player === player
+      {
+        return
+      }
+
+      // Remove previous controller if any
+      self.playerViewController?.willMove(toParent: nil)
+      self.playerViewController?.view.removeFromSuperview()
+      self.playerViewController?.removeFromParent()
+
+      let controller = AVPlayerViewController()
+      controller.player = player
+      controller.showsPlaybackControls = controls
+      controller.videoGravity = self.resizeMode.toVideoGravity()
+      controller.view.frame = playerView.bounds
+      controller.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+      controller.view.backgroundColor = .clear
+
+      // We manage this manually in NowPlayingInfoCenterManager
+      controller.updatesNowPlayingInfoCenter = false
+
+      if #available(iOS 16.0, *) {
+        if let initialSpeed = controller.speeds.first(where: { $0.rate == player.rate }) {
+          controller.selectSpeed(initialSpeed)
+        }
+      }
+       // Disable video frame analysis to prevent visual lookup
+      if #available(iOS 16.0, iPadOS 16.0, macCatalyst 18.0, *) {
+        controller.allowsVideoFrameAnalysis = false
+      }
+
+      // Find nearest UIViewController
+      if let parentVC = self.findViewController() {
+        parentVC.addChild(controller)
+        playerView.addSubview(controller.view)
+        controller.didMove(toParent: parentVC)
+        self.playerViewController = controller
+      }
+    }
+  }
+
+  // Helper to find nearest UIViewController
+  private func findViewController() -> UIViewController? {
+    var responder: UIResponder? = self
+    while let r = responder {
+      if let vc = r as? UIViewController {
+        return vc
+      }
+      responder = r.next
+    }
+    return nil
+  }
+
+  public override func willMove(toSuperview newSuperview: UIView?) {
+    super.willMove(toSuperview: newSuperview)
+
+    if newSuperview == nil {
+      PluginsRegistry.shared.notifyVideoViewDestroyed(view: self)
+
+      // We want to disable this when view is about to unmount
+      if keepScreenAwake {
+        keepScreenAwake = false
+      }
+    } else {
+      PluginsRegistry.shared.notifyVideoViewCreated(view: self)
+
+      // We want to restore keepScreenAwake after component remount
+      if _keepScreenAwake {
+        keepScreenAwake = true
+      }
+    }
+  }
+
+  public override func layoutSubviews() {
+    super.layoutSubviews()
+
+    // Update the frame of the playerViewController's view when the view's layout changes
+    playerViewController?.view.frame = playerView?.bounds ?? .zero
+    playerViewController?.contentOverlayView?.frame = playerView?.bounds ?? .zero
+    for subview in playerViewController?.contentOverlayView?.subviews ?? [] {
+      subview.frame = playerView?.bounds ?? .zero
+    }
+  }
+
+  public func enterFullscreen() throws {
+    guard let playerViewController else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+
+    DispatchQueue.main.async {
+      playerViewController.enterFullscreen(animated: true)
+    }
+  }
+
+  public func exitFullscreen() throws {
+    guard let playerViewController else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+
+    DispatchQueue.main.async {
+      playerViewController.exitFullscreen(animated: true)
+    }
+  }
+
+  public func startPictureInPicture() throws {
+    guard let playerViewController else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+
+    guard AVPictureInPictureController.isPictureInPictureSupported() else {
+      throw VideoViewError.pictureInPictureNotSupported.error()
+    }
+
+    DispatchQueue.main.async {
+      // Here we skip error handling for simplicity
+      // We do check for PiP support earlier in the code
+      try? playerViewController.startPictureInPicture()
+    }
+  }
+
+  public func stopPictureInPicture() throws {
+    guard let playerViewController else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+
+    DispatchQueue.main.async {
+      // Here we skip error handling for simplicity
+      // We do check for PiP support earlier in the code
+      playerViewController.stopPictureInPicture()
+    }
+  }
+}

package/ios/view/VideoComponentViewObserver.swift

@@ -0,0 +1,144 @@
+//
+//  VideoComponentViewObserver.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 06/05/2025.
+//
+
+import Foundation
+import AVKit
+import AVFoundation
+
+protocol VideoComponentViewDelegate: AnyObject {
+  func onPictureInPictureChange(_ isActive: Bool)
+  func onFullscreenChange(_ isActive: Bool)
+  func willEnterFullscreen()
+  func willExitFullscreen()
+  func willEnterPictureInPicture()
+  func willExitPictureInPicture()
+  func onReadyToDisplay()
+}
+
+// Map delegate methods to view manager methods
+final class VideoViewDelegate: NSObject, VideoComponentViewDelegate {
+  weak var viewManager: HybridVideoViewViewManager?
+  
+  init(viewManager: HybridVideoViewViewManager) {
+    self.viewManager = viewManager
+  }
+  
+  func onPictureInPictureChange(_ isActive: Bool) {
+    viewManager?.onPictureInPictureChange(isActive)
+  }
+  
+  func onFullscreenChange(_ isActive: Bool) {
+    viewManager?.onFullscreenChange(isActive)
+  }
+  
+  func willEnterFullscreen() {
+    viewManager?.willEnterFullscreen()
+  }
+  
+  func willExitFullscreen() {
+    viewManager?.willExitFullscreen()
+  }
+  
+  func willEnterPictureInPicture() {
+    viewManager?.willEnterPictureInPicture()
+  }
+  
+  func willExitPictureInPicture() {
+    viewManager?.willExitPictureInPicture()
+  }
+  
+  func onReadyToDisplay() {
+    if let player = viewManager?.player as? HybridVideoPlayer {
+      player._eventEmitter?.onReadyToDisplay()
+    }
+  }
+}
+
+class VideoComponentViewObserver: NSObject, AVPlayerViewControllerDelegate {
+  private weak var view: VideoComponentView?
+  
+  var delegate: VideoViewDelegate? {
+    get {
+      return view?.delegate
+    }
+  }
+  
+  var playerViewController: AVPlayerViewController? {
+    return view?.playerViewController
+  }
+  
+  // playerViewController observers
+  var onReadyToDisplayObserver: NSKeyValueObservation?
+  
+  init(view: VideoComponentView) {
+    self.view = view
+    super.init()
+  }
+  
+  func initializePlayerViewContorollerObservers() {
+    guard let playerViewController = playerViewController else {
+      return
+    }
+    
+    onReadyToDisplayObserver = playerViewController.observe(\.isReadyForDisplay, options: [.new]) { [weak self] _, change in
+      guard let self = self else { return }
+      if change.newValue == true {
+        self.delegate?.onReadyToDisplay()
+      }
+    }
+  }
+  
+  func removePlayerViewControllerObservers() {
+    onReadyToDisplayObserver?.invalidate()
+    onReadyToDisplayObserver = nil
+  }
+  
+  func updatePlayerViewControllerObservers() {
+    removePlayerViewControllerObservers()
+    initializePlayerViewContorollerObservers()
+  }
+  
+  func playerViewControllerDidStartPictureInPicture(_: AVPlayerViewController) {
+    delegate?.onPictureInPictureChange(true)
+  }
+  
+  func playerViewControllerDidStopPictureInPicture(_: AVPlayerViewController) {
+    delegate?.onPictureInPictureChange(false)
+  }
+  
+  func playerViewControllerWillStartPictureInPicture(_: AVPlayerViewController) {
+    delegate?.willEnterPictureInPicture()
+  }
+  
+  func playerViewControllerWillStopPictureInPicture(_: AVPlayerViewController) {
+    delegate?.willExitPictureInPicture()
+  }
+  
+  func playerViewController(
+    _: AVPlayerViewController,
+    willEndFullScreenPresentationWithAnimationCoordinator coordinator: UIViewControllerTransitionCoordinator
+  ) {
+    delegate?.willExitFullscreen()
+    
+    coordinator.animate(alongsideTransition: nil) { [weak self] _ in
+      guard let self = self else { return }
+      self.delegate?.onFullscreenChange(false)
+    }
+  }
+  
+  func playerViewController(
+    _: AVPlayerViewController,
+    willBeginFullScreenPresentationWithAnimationCoordinator coordinator: UIViewControllerTransitionCoordinator
+  ) {
+    delegate?.willEnterFullscreen()
+    
+    coordinator.animate(alongsideTransition: nil) { [weak self] _ in
+      guard let self = self else { return }
+      self.delegate?.onFullscreenChange(true)
+    }
+  }
+}

package/ios/view/fabric/RCTVideoViewComponentView.h

@@ -0,0 +1,10 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTVideoViewComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END