@bluebillywig/react-native-bb-player 8.42.14 → 8.44.0

package/ios/BBPlayerView.swift

@@ -33,8 +33,13 @@ private func log(_ message: String, level: LogLevel = .debug) {
   #endif
 }
 
-class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
-  private var playerController: BBPlayerViewController = BBPlayerViewController()
+// MARK: - BBPlayerView
+// Simplified architecture: BBPlayerView directly hosts BBNativePlayerView without intermediate view controller
+// This reduces view hierarchy depth and eliminates extra layout passes for better performance/battery life
+
+class BBPlayerView: UIView, BBNativePlayerViewDelegate {
+  // Direct reference to SDK player view (no intermediate view controller)
+  private var playerView: BBNativePlayerView?
   private var hasSetup: Bool = false
 
   // Timer for periodic time updates (opt-in for performance)
@@ -42,28 +47,26 @@ class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
   private var isPlaying: Bool = false
   private var currentDuration: Double = 0.0
   private var lastKnownTime: Double = 0.0
-  private var playbackStartTimestamp: CFTimeInterval = 0  // Use CFTimeInterval for CACurrentMediaTime
+  private var playbackStartTimestamp: CFTimeInterval = 0
   private var lastEmittedTime: Double = 0.0
   private var isInFullscreen: Bool = false
   private var backgroundObserver: NSObjectProtocol?
   private var foregroundObserver: NSObjectProtocol?
   // Independent Google Cast button for showing the cast picker
   private var independentCastButton: GCKUICastButton?
+  // Store parent view controller reference for SDK
+  private weak var parentViewController: UIViewController?
 
   // MARK: - Props (set from React Native)
 
   @objc var jsonUrl: String = "" {
     didSet {
-      playerController.jsonUrl = jsonUrl
       setupPlayerIfNeeded()
     }
   }
 
   @objc var options: NSDictionary = [:] {
     didSet {
-      if let optionsDict = options as? [String: Any] {
-        playerController.options = optionsDict
-      }
       setupPlayerIfNeeded()
     }
   }
@@ -72,12 +75,9 @@ class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
     didSet {
       log("Time updates \(enableTimeUpdates ? "enabled" : "disabled")")
 
-      // If disabling while timer is running, stop it
       if !enableTimeUpdates && timeUpdateTimer != nil {
         stopTimeUpdates()
-      }
-      // If enabling while playing, start it
-      else if enableTimeUpdates && isPlaying && timeUpdateTimer == nil {
+      } else if enableTimeUpdates && isPlaying && timeUpdateTimer == nil {
         startTimeUpdates()
       }
     }
@@ -126,13 +126,11 @@ class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
   @objc var onDidTriggerTimeUpdate: RCTDirectEventBlock?
   @objc var onDidTriggerApiReady: RCTDirectEventBlock?
 
-  // Override intrinsicContentSize to tell React Native this view wants to fill available space
   override var intrinsicContentSize: CGSize {
     return CGSize(width: UIView.noIntrinsicMetric, height: UIView.noIntrinsicMetric)
   }
 
   private func setupPlayerIfNeeded() {
-    // Only setup once we have both jsonUrl and we're in the window
     guard !jsonUrl.isEmpty, window != nil, !hasSetup else { return }
     hasSetup = true
     setupPlayer()
@@ -143,86 +141,62 @@ class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
 
     if window != nil {
       log("BBPlayerView.didMoveToWindow - view added to window")
-      // Ensure this view respects its frame from React Native layout
-      self.clipsToBounds = false  // Allow settings overlay to render outside bounds
+      self.clipsToBounds = false
+
+      // Optimize layer for video playback - reduce compositing overhead
+      self.layer.isOpaque = true
+      self.layer.drawsAsynchronously = true
+      self.isOpaque = true
+
+      // Register with view registry for command dispatch (supports New Architecture)
+      if let tag = self.reactTag {
+        BBPlayerViewRegistry.shared.register(self, tag: tag.intValue)
+      }
 
-      // Set up lifecycle observers to pause timer when app goes to background (saves battery)
       setupAppLifecycleObservers()
 
       // Find the parent view controller from the responder chain
-      var parentVC: UIViewController?
       var responder = self.next
       while responder != nil {
         if let viewController = responder as? UIViewController {
-          parentVC = viewController
+          parentViewController = viewController
           break
         }
         responder = responder?.next
       }
 
-      // Add playerController as a child view controller for proper fullscreen support
-      if let parentVC = parentVC {
-        log("Found parent view controller: \(type(of: parentVC))")
-        parentVC.addChild(playerController)
-        addSubview(playerController.view)
-
-        playerController.view.translatesAutoresizingMaskIntoConstraints = false
-
-        NSLayoutConstraint.activate([
-          playerController.view.topAnchor.constraint(equalTo: topAnchor),
-          playerController.view.leadingAnchor.constraint(equalTo: leadingAnchor),
-          playerController.view.trailingAnchor.constraint(equalTo: trailingAnchor),
-          playerController.view.bottomAnchor.constraint(equalTo: bottomAnchor),
-        ])
-
-        playerController.didMove(toParent: parentVC)
-        playerController.setViewSize = self.setViewSize
-        playerController.delegate = self
-        log("Player controller added to parent VC, delegate set to BBPlayerView")
-
-        // Try to setup if we have jsonUrl
-        setupPlayerIfNeeded()
+      if parentViewController != nil {
+        log("Found parent view controller: \(type(of: parentViewController!))")
       } else {
         log("WARNING - Could not find parent view controller!", level: .warning)
       }
 
-    } else if window == nil {
+      setupPlayerIfNeeded()
+    } else {
       log("BBPlayerView.didMoveToWindow - view removed from window, isInFullscreen: \(isInFullscreen)")
 
-      // Stop time update timer to save CPU/battery when view is not visible
-      // Skip this during fullscreen transitions to avoid interrupting playback
+      // Unregister from view registry when removed from window (unless in fullscreen)
+      if !isInFullscreen, let tag = self.reactTag {
+        BBPlayerViewRegistry.shared.unregister(tag: tag.intValue)
+      }
+
       if !isInFullscreen {
         stopTimeUpdates()
       }
-
-      // Don't tear down the view controller hierarchy when the view is removed from the window.
-      // This happens during fullscreen transitions, and the SDK needs the hierarchy intact
-      // to properly restore the player after exiting fullscreen.
-      // React Native will handle actual cleanup when the component unmounts.
     }
   }
 
-  // Callback for height changes (used with allowCollapseExpand)
-  private func setViewSize(_ size: CGSize) {
-    // This is called by the player controller when the view size changes
-    // In React Native, we generally let the parent handle sizing
-  }
-
   // Start periodic time updates (1x per second, only if enabled)
   private func startTimeUpdates() {
-    // Skip if time updates are disabled or timer already running
     guard enableTimeUpdates, timeUpdateTimer == nil else { return }
 
     timeUpdateTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
       guard let self = self, self.isPlaying else { return }
 
-      // Use CACurrentMediaTime() instead of Date() - much more efficient (no system call overhead)
       let elapsedSeconds = CACurrentMediaTime() - self.playbackStartTimestamp
       let estimatedTime = self.lastKnownTime + elapsedSeconds
       let currentTime = min(estimatedTime, self.currentDuration)
 
-      // Only emit if we have valid time values and time changed significantly (>0.5s)
-      // This reduces unnecessary bridge calls and React re-renders
       if self.currentDuration > 0 && abs(currentTime - self.lastEmittedTime) >= 0.5 {
         self.lastEmittedTime = currentTime
         self.onDidTriggerTimeUpdate?([
@@ -233,34 +207,33 @@ class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
     }
   }
 
-  // Stop periodic time updates
   private func stopTimeUpdates() {
     timeUpdateTimer?.invalidate()
     timeUpdateTimer = nil
   }
 
-  // Clean up timers, observers, and views to prevent memory leaks
   deinit {
+    // Unregister from view registry
+    if let tag = self.reactTag {
+      BBPlayerViewRegistry.shared.unregister(tag: tag.intValue)
+    }
     stopTimeUpdates()
     removeAppLifecycleObservers()
     independentCastButton?.removeFromSuperview()
     independentCastButton = nil
   }
 
-  // MARK: - App Lifecycle Management (Battery Optimization)
+  // MARK: - App Lifecycle Management
 
   private func setupAppLifecycleObservers() {
-    // Only set up once
     guard backgroundObserver == nil else { return }
 
-    // Pause timer when app goes to background to save battery
     backgroundObserver = NotificationCenter.default.addObserver(
       forName: UIApplication.didEnterBackgroundNotification,
       object: nil,
       queue: .main
     ) { [weak self] _ in
       guard let self = self else { return }
-      // Save current time before pausing timer so we can resume accurately
       if self.isPlaying {
         self.lastKnownTime = self.calculateCurrentTime()
       }
@@ -268,7 +241,6 @@ class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
       log("Timer paused - app entered background", level: .debug)
     }
 
-    // Resume timer when app comes back to foreground
     foregroundObserver = NotificationCenter.default.addObserver(
       forName: UIApplication.willEnterForegroundNotification,
       object: nil,
@@ -276,7 +248,6 @@ class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
     ) { [weak self] _ in
       guard let self = self else { return }
       if self.isPlaying && self.enableTimeUpdates {
-        // Reset timestamp to now for accurate time calculation after background
         self.playbackStartTimestamp = CACurrentMediaTime()
         self.startTimeUpdates()
         log("Timer resumed - app entered foreground", level: .debug)
@@ -295,300 +266,377 @@ class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
     }
   }
 
-  func bbPlayerViewController(
-    _ controller: BBPlayerViewController, didTriggerEvent event: BBPlayerEvent
-  ) {
-    switch event {
-    case .requestCollapse:
-      onDidRequestCollapse?([:])
+  // MARK: - Player Setup (Simplified - no intermediate view controller)
+
+  func setupPlayer() {
+    guard let parentVC = parentViewController else {
+      log("ERROR - Cannot setup player without parent view controller", level: .error)
+      return
+    }
 
-    case .requestExpand:
-      onDidRequestExpand?([:])
+    log("BBPlayerView.setupPlayer() - creating player with jsonUrl: \(jsonUrl)")
 
-    case .failWithError(let error):
-      onDidFailWithError?(["payload": error as Any])
+    // Remove any existing player view
+    playerView?.removeFromSuperview()
 
-    case .requestOpenUrl(let url):
-      onDidRequestOpenUrl?(["payload": url as Any])
+    // Convert options dictionary
+    var optionsDict: [String: Any] = [:]
+    if let opts = options as? [String: Any] {
+      optionsDict = opts
+    }
 
-    case .setupWithJsonUrl(let url):
-      onDidSetupWithJsonUrl?(["payload": url as Any])
+    // Create player view directly using SDK factory method
+    // Pass the parent view controller so SDK can present fullscreen modals
+    playerView = BBNativePlayer.createPlayerView(
+      uiViewController: parentVC,
+      frame: bounds,
+      jsonUrl: jsonUrl,
+      options: optionsDict
+    )
+
+    if let pv = playerView {
+      // Add player view directly to BBPlayerView (no intermediate view controller)
+      addSubview(pv)
+
+      pv.translatesAutoresizingMaskIntoConstraints = false
+      NSLayoutConstraint.activate([
+        pv.topAnchor.constraint(equalTo: topAnchor),
+        pv.leadingAnchor.constraint(equalTo: leadingAnchor),
+        pv.trailingAnchor.constraint(equalTo: trailingAnchor),
+        pv.bottomAnchor.constraint(equalTo: bottomAnchor)
+      ])
 
-    case .adError(let error):
-      onDidTriggerAdError?(["payload": error as Any])
+      // Set ourselves as the delegate directly
+      pv.delegate = self
 
-    case .adFinished:
-      onDidTriggerAdFinished?([:])
+      log("Player view created and added directly to BBPlayerView")
+    } else {
+      log("ERROR - playerView is nil after createPlayerView!", level: .error)
+    }
+  }
 
-    case .adLoaded:
-      onDidTriggerAdLoaded?([:])
+  // MARK: - BBNativePlayerViewDelegate Implementation
 
-    case .adLoadStart:
-      onDidTriggerAdLoadStart?([:])
+  func bbNativePlayerView(didRequestCollapse playerView: BBNativePlayerView) {
+    onDidRequestCollapse?([:])
+  }
 
-    case .adNotFound:
-      onDidTriggerAdNotFound?([:])
+  func bbNativePlayerView(didRequestExpand playerView: BBNativePlayerView) {
+    onDidRequestExpand?([:])
+  }
 
-    case .adQuartile1:
-      onDidTriggerAdQuartile1?([:])
+  func bbNativePlayerView(playerView: BBNativePlayerView, didFailWithError error: String?) {
+    onDidFailWithError?(["payload": error as Any])
+  }
 
-    case .adQuartile2:
-      onDidTriggerAdQuartile2?([:])
+  func didRequestOpenUrl(url: String?) {
+    onDidRequestOpenUrl?(["payload": url as Any])
+  }
 
-    case .adQuartile3:
-      onDidTriggerAdQuartile3?([:])
+  func didSetupWithJsonUrl(url: String?) {
+    onDidSetupWithJsonUrl?(["payload": url as Any])
+  }
 
-    case .adStarted:
-      onDidTriggerAdStarted?([:])
+  func bbNativePlayerView(playerView: BBNativePlayerView, didTriggerAdError error: String?) {
+    onDidTriggerAdError?(["payload": error as Any])
+  }
 
-    case .allAdsCompleted:
-      onDidTriggerAllAdsCompleted?([:])
+  func bbNativePlayerView(didTriggerAdFinished playerView: BBNativePlayerView) {
+    onDidTriggerAdFinished?([:])
+  }
 
-    case .autoPause(let why):
-      onDidTriggerAutoPause?(["why": why as Any])
+  func bbNativePlayerView(didTriggerAdLoadStart playerView: BBNativePlayerView) {
+    onDidTriggerAdLoadStart?([:])
+  }
 
-    case .autoPausePlay(let why):
-      onDidTriggerAutoPausePlay?(["why": why as Any])
+  func bbNativePlayerView(didTriggerAdLoaded playerView: BBNativePlayerView) {
+    onDidTriggerAdLoaded?([:])
+  }
 
-    case .canPlay:
-      onDidTriggerCanPlay?([:])
+  func bbNativePlayerView(didTriggerAdNotFound playerView: BBNativePlayerView) {
+    onDidTriggerAdNotFound?([:])
+  }
 
-    case .customStatistics(let ident, let ev, let aux):
-      onDidTriggerCustomStatistics?([
-        "ident": ident,
-        "ev": ev,
-        "aux": aux,
-      ])
+  func bbNativePlayerView(didTriggerAdQuartile1 playerView: BBNativePlayerView) {
+    onDidTriggerAdQuartile1?([:])
+  }
 
-    case .durationChange(let duration):
-      currentDuration = duration
-      onDidTriggerDurationChange?(["duration": duration as Any])
+  func bbNativePlayerView(didTriggerAdQuartile2 playerView: BBNativePlayerView) {
+    onDidTriggerAdQuartile2?([:])
+  }
 
-    case .ended:
-      isPlaying = false
-      stopTimeUpdates()
-      onDidTriggerEnded?([:])
+  func bbNativePlayerView(didTriggerAdQuartile3 playerView: BBNativePlayerView) {
+    onDidTriggerAdQuartile3?([:])
+  }
 
-    case .fullscreen:
-      isInFullscreen = true
-      onDidTriggerFullscreen?([:])
+  func bbNativePlayerView(didTriggerAdStarted playerView: BBNativePlayerView) {
+    onDidTriggerAdStarted?([:])
+  }
 
-    case .mediaClipFailed:
-      onDidTriggerMediaClipFailed?([:])
+  func bbNativePlayerView(didTriggerAllAdsCompleted playerView: BBNativePlayerView) {
+    onDidTriggerAllAdsCompleted?([:])
+  }
 
-    case .mediaClipLoaded(let clipData):
-      onDidTriggerMediaClipLoaded?(clipData.toDictionary() as [String: Any])
+  func bbNativePlayerView(didTriggerAutoPause playerView: BBNativePlayerView) {
+    onDidTriggerAutoPause?([:])
+  }
 
-    case .modeChange(let mode):
-      onDidTriggerModeChange?(["mode": mode as Any])
+  func bbNativePlayerView(didTriggerAutoPausePlay playerView: BBNativePlayerView) {
+    onDidTriggerAutoPausePlay?([:])
+  }
 
-    case .pause:
-      isPlaying = false
-      stopTimeUpdates()
-      onDidTriggerPause?([:])
+  func bbNativePlayerView(didTriggerCanPlay playerView: BBNativePlayerView) {
+    onDidTriggerCanPlay?([:])
+  }
 
-    case .phaseChange(let phase):
-      onDidTriggerPhaseChange?(["phase": (phase?.name ?? nil) as Any])
+  func bbNativePlayerView(
+    didTriggerCustomStatistics playerView: BBNativePlayerView, ident: String, ev: String,
+    aux: [String: String]
+  ) {
+    onDidTriggerCustomStatistics?([
+      "ident": ident,
+      "ev": ev,
+      "aux": aux,
+    ])
+  }
 
-    case .play:
-      onDidTriggerPlay?([:])
+  func bbNativePlayerView(
+    playerView: BBNativePlayerView, didTriggerDurationChange duration: Double
+  ) {
+    currentDuration = duration
+    onDidTriggerDurationChange?(["duration": duration as Any])
+  }
 
-    case .playing:
-      isPlaying = true
-      playbackStartTimestamp = CACurrentMediaTime()  // More efficient than Date()
-      lastEmittedTime = 0.0  // Reset to ensure immediate time update on play
-      lastKnownTime = calculateCurrentTime()  // Update to ensure accuracy between events
-      startTimeUpdates()
-      onDidTriggerPlaying?([:])
+  func bbNativePlayerView(didTriggerEnded playerView: BBNativePlayerView) {
+    isPlaying = false
+    stopTimeUpdates()
+    onDidTriggerEnded?([:])
+  }
 
-    case .projectLoaded(let projectData):
-      onDidTriggerProjectLoaded?(projectData.toDictionary() as [String: Any])
+  func bbNativePlayerView(didTriggerFullscreen playerView: BBNativePlayerView) {
+    isInFullscreen = true
+    log("FULLSCREEN ENTRY")
 
-    case .retractFullscreen:
-      isInFullscreen = false
-      // Note: Orientation reset is handled by BBPlayerViewController.bbNativePlayerView(didTriggerRetractFullscreen:)
-      // to avoid duplicate calls which cause unnecessary CPU/GPU work
-      onDidTriggerRetractFullscreen?([:])
+    // Enable landscape orientation for fullscreen
+    if let orientationLockClass = NSClassFromString("OrientationLock") as? NSObject.Type {
+      orientationLockClass.setValue(true, forKey: "isFullscreen")
+    }
 
-    case .seeked(let seekOffset):
-      // Update lastKnownTime based on seek and reset playback timestamp
-      lastKnownTime = seekOffset ?? 0.0
-      playbackStartTimestamp = CACurrentMediaTime()  // More efficient than Date()
-      lastEmittedTime = 0.0  // Reset to ensure immediate time update after seek
-      onDidTriggerSeeked?(["payload": seekOffset as Any])
+    DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+      guard let self = self, let parentVC = self.parentViewController else { return }
+      if let presentedVC = parentVC.presentedViewController {
+        if #available(iOS 16.0, *) {
+          presentedVC.setNeedsUpdateOfSupportedInterfaceOrientations()
+        }
+        UIViewController.attemptRotationToDeviceOrientation()
+      }
+    }
 
-    case .seeking:
-      onDidTriggerSeeking?([:])
+    onDidTriggerFullscreen?([:])
+  }
 
-    case .stall:
-      onDidTriggerStall?([:])
+  func bbNativePlayerView(didTriggerMediaClipFailed playerView: BBNativePlayerView) {
+    onDidTriggerMediaClipFailed?([:])
+  }
 
-    case .stateChange(let state):
-      onDidTriggerStateChange?(["state": (state?.name ?? nil) as Any])
+  func bbNativePlayerView(
+    playerView: BBNativePlayerView, didTriggerMediaClipLoaded data: MediaClip
+  ) {
+    onDidTriggerMediaClipLoaded?(data.toDictionary() as [String: Any])
+  }
 
-    case .viewFinished:
-      onDidTriggerViewFinished?([:])
+  func bbNativePlayerView(didTriggerModeChange playerView: BBNativePlayerView, mode: String?) {
+    onDidTriggerModeChange?(["mode": mode as Any])
+  }
 
-    case .viewStarted:
-      onDidTriggerViewStarted?([:])
+  func bbNativePlayerView(didTriggerPause playerView: BBNativePlayerView) {
+    isPlaying = false
+    stopTimeUpdates()
+    onDidTriggerPause?([:])
+  }
 
-    case .volumeChange(let volume):
-      onDidTriggerVolumeChange?([
-        "volume": volume,
-        "muted": (volume == 0.0)
-      ])
+  func bbNativePlayerView(playerView: BBNativePlayerView, didTriggerPhaseChange phase: Phase?) {
+    onDidTriggerPhaseChange?(["phase": (phase?.name ?? nil) as Any])
+  }
 
-    case .apiReady:
-      // Note: We create the independent cast button lazily when needed, not during init
-      // This avoids timing issues with Google Cast SDK initialization
-      onDidTriggerApiReady?([:])
-    }
+  func bbNativePlayerView(didTriggerPlay playerView: BBNativePlayerView) {
+    onDidTriggerPlay?([:])
   }
 
-  // Setup independent cast button that works alongside the SDK
-  private func setupIndependentCastButton() {
-    // CRITICAL: Check if Google Cast SDK is initialized before creating button
-    if !GCKCastContext.isSharedInstanceInitialized() {
-      log("ERROR - Cannot create cast button: Google Cast SDK not initialized yet", level: .error)
-      return
-    }
+  func bbNativePlayerView(didTriggerPlaying playerView: BBNativePlayerView) {
+    isPlaying = true
+    playbackStartTimestamp = CACurrentMediaTime()
+    lastEmittedTime = 0.0
+    lastKnownTime = calculateCurrentTime()
+    startTimeUpdates()
+    onDidTriggerPlaying?([:])
+  }
 
-    log("Creating independent GCKUICastButton (SDK confirmed initialized)")
+  func bbNativePlayerView(playerView: BBNativePlayerView, didTriggerProjectLoaded data: Project) {
+    onDidTriggerProjectLoaded?(data.toDictionary() as [String: Any])
+  }
 
-    // Create an independent GCKUICastButton separate from the SDK
-    // This button will interact with the Google Cast SDK's session manager
-    // The Blue Billywig SDK already listens to GCKSessionManager notifications
-    // so it will automatically detect and handle any cast sessions we create
-    independentCastButton = GCKUICastButton(frame: CGRect(x: -1000, y: -1000, width: 1, height: 1))
+  func bbNativePlayerView(didTriggerRetractFullscreen playerView: BBNativePlayerView) {
+    isInFullscreen = false
+    log("FULLSCREEN EXIT")
 
-    guard let castButton = independentCastButton else {
-      log("ERROR - Failed to create independent cast button", level: .error)
-      return
+    // Disable landscape orientation
+    if let orientationLockClass = NSClassFromString("OrientationLock") as? NSObject.Type {
+      orientationLockClass.setValue(false, forKey: "isFullscreen")
     }
 
-    // Add it to the view hierarchy but keep it invisible and offscreen
-    // We need it in the hierarchy so it can present dialogs, but we don't want to see it
-    castButton.alpha = 0.0  // Completely transparent
-    castButton.isUserInteractionEnabled = false  // Can't be tapped
-    addSubview(castButton)
+    // Force rotation back to portrait
+    if #available(iOS 16.0, *) {
+      if let windowScene = window?.windowScene {
+        windowScene.requestGeometryUpdate(.iOS(interfaceOrientations: .portrait))
+      }
+    } else {
+      UIDevice.current.setValue(UIInterfaceOrientation.portrait.rawValue, forKey: "orientation")
+    }
 
-    log("Successfully created and added independent GCKUICastButton to view hierarchy")
-  }
+    UIViewController.attemptRotationToDeviceOrientation()
 
-  // Safe handler for cast button taps - uses an independent GCKUICastButton
-  @objc private func handleCastButtonTap() {
-    log("Cast button tapped")
+    onDidTriggerRetractFullscreen?([:])
+  }
 
-    // CRITICAL: Verify Google Cast SDK is initialized before proceeding
-    if !GCKCastContext.isSharedInstanceInitialized() {
-      log("ERROR - Cast button tapped but Google Cast SDK not initialized yet", level: .error)
-      return
-    }
+  func bbNativePlayerView(playerView: BBNativePlayerView, didTriggerSeeked seekOffset: Double) {
+    lastKnownTime = seekOffset
+    playbackStartTimestamp = CACurrentMediaTime()
+    lastEmittedTime = 0.0
+    onDidTriggerSeeked?(["payload": seekOffset as Any])
+  }
 
-    // Create the button lazily on first use
-    if independentCastButton == nil {
-      setupIndependentCastButton()
-    }
+  func bbNativePlayerView(didTriggerSeeking playerView: BBNativePlayerView) {
+    onDidTriggerSeeking?([:])
+  }
 
-    guard let castButton = independentCastButton else {
-      log("ERROR - Failed to create independent cast button", level: .error)
-      return
-    }
+  func bbNativePlayerView(didTriggerStall playerView: BBNativePlayerView) {
+    onDidTriggerStall?([:])
+  }
 
-    // Trigger the button to show the cast device picker
-    // When a device is selected, GCKSessionManager will notify the SDK
-    log("Triggering independent GCKUICastButton to show cast picker")
-    castButton.sendActions(for: .touchUpInside)
+  func bbNativePlayerView(playerView: BBNativePlayerView, didTriggerStateChange state: State?) {
+    onDidTriggerStateChange?(["state": (state?.name ?? nil) as Any])
   }
 
-  func setupPlayer() {
-    log("BBPlayerView.setupPlayer() called with jsonUrl: \(playerController.jsonUrl)")
-    playerController.setupPlayer()
-    log("BBPlayerView.setupPlayer() completed")
+  func bbNativePlayerView(didTriggerViewFinished playerView: BBNativePlayerView) {
+    onDidTriggerViewFinished?([:])
   }
 
-  func adMediaHeight() -> Int? {
-    return playerController.playerView?.player.adMediaHeight
+  func bbNativePlayerView(didTriggerViewStarted playerView: BBNativePlayerView) {
+    onDidTriggerViewStarted?([:])
   }
 
-  func adMediaWidth() -> Int? {
-    return playerController.playerView?.player.adMediaWidth
+  func bbNativePlayerView(didTriggerVolumeChange playerView: BBNativePlayerView, volume: Double) {
+    onDidTriggerVolumeChange?([
+      "volume": volume,
+      "muted": (volume == 0.0)
+    ])
   }
 
-  func adMediaClip() -> Any? {
-    return playerController.playerView?.player.clipData?.toDictionary()
+  func bbNativePlayerView(didTriggerApiReady playerView: BBNativePlayerView) {
+    onDidTriggerApiReady?([:])
   }
 
-  func controls() -> Bool? {
-    return nil
+  // MARK: - Cast Button Setup
+
+  private func setupIndependentCastButton() {
+    if !GCKCastContext.isSharedInstanceInitialized() {
+      log("ERROR - Cannot create cast button: Google Cast SDK not initialized yet", level: .error)
+      return
+    }
+
+    independentCastButton = GCKUICastButton(frame: CGRect(x: -1000, y: -1000, width: 1, height: 1))
+
+    guard let castButton = independentCastButton else {
+      log("ERROR - Failed to create independent cast button", level: .error)
+      return
+    }
+
+    castButton.alpha = 0.0
+    castButton.isUserInteractionEnabled = false
+    addSubview(castButton)
   }
 
   // MARK: - Private Helper Methods
 
-  /// Calculate estimated current time based on playback state
-  /// iOS SDK doesn't expose direct currentTime property, so we estimate it
   private func calculateCurrentTime() -> Double {
     if isPlaying && playbackStartTimestamp > 0 {
-      // Use CACurrentMediaTime() - more efficient than Date() (no system call overhead)
       let elapsedSeconds = CACurrentMediaTime() - playbackStartTimestamp
       let estimatedTime = lastKnownTime + elapsedSeconds
       return min(estimatedTime, currentDuration)
     } else {
-      // When paused or not playing, return last known time
       return lastKnownTime
     }
   }
 
+  // MARK: - Public API Methods
+
+  func adMediaHeight() -> Int? {
+    return playerView?.player.adMediaHeight
+  }
+
+  func adMediaWidth() -> Int? {
+    return playerView?.player.adMediaWidth
+  }
+
+  func clipData() -> Any? {
+    return playerView?.player.clipData?.toDictionary()
+  }
+
+  func controls() -> Bool? {
+    return nil
+  }
+
   func currentTime() -> Double? {
     return calculateCurrentTime()
   }
 
   func duration() -> Double? {
-    return playerController.playerView?.player.duration
+    return playerView?.player.duration
   }
 
   func inView() -> Bool? {
-    return playerController.playerView?.player.inView
+    return playerView?.player.inView
   }
 
   func mode() -> String? {
-    return playerController.playerView?.player.mode
+    return playerView?.player.mode
   }
 
   func muted() -> Bool? {
-    return playerController.playerView?.player.muted
+    return playerView?.player.muted
   }
 
   func phase() -> Any? {
-    return playerController.playerView?.player.phase?.name
+    return playerView?.player.phase?.name
   }
 
   func playoutData() -> Any? {
-    return playerController.playerView?.player.playoutData?.toDictionary()
+    return playerView?.player.playoutData?.toDictionary()
   }
 
   func projectData() -> Any? {
-    return playerController.playerView?.player.projectData?.toDictionary()
+    return playerView?.player.projectData?.toDictionary()
   }
 
   func state() -> Any? {
-    return playerController.playerView?.player.state?.name
+    return playerView?.player.state?.name
   }
 
   func volume() -> Float? {
-    return playerController.playerView?.player.volume
+    return playerView?.player.volume
   }
 
   func autoPlayNextCancel() {
-    playerController.playerView?.player.autoPlayNextCancel()
+    playerView?.player.autoPlayNextCancel()
   }
 
   func collapse() {
-    playerController.playerView?.player.collapse()
+    playerView?.player.collapse()
   }
 
   func expand() {
-    playerController.playerView?.player.expand()
+    playerView?.player.expand()
   }
 
   func enterFullscreen() {
@@ -600,131 +648,188 @@ class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
   }
 
   private func enterFullscreenWithLandscapeForce(forceLandscape: Bool) {
-    // CRITICAL FIX: Set goingFullScreen flag on BBNativePlayerViewController
-    // The SDK's BBNativePlayerViewController.supportedInterfaceOrientations only returns
-    // .allButUpsideDown when goingFullScreen == true. Without this, the fullscreen modal
-    // is stuck in portrait orientation.
-    if let playerView = playerController.playerView?.player as? NSObject {
-      // Access the private bbNativePlayerViewController using Key-Value Coding
-      if let bbViewController = playerView.value(forKey: "bbNativePlayerViewController") as? NSObject {
+    // Set goingFullScreen flag on BBNativePlayerViewController for proper orientation support
+    if let player = playerView?.player as? NSObject {
+      if let bbViewController = player.value(forKey: "bbNativePlayerViewController") as? NSObject {
         bbViewController.setValue(true, forKey: "goingFullScreen")
-        log("Set goingFullScreen = true on BBNativePlayerViewController before enterFullScreen", level: .info)
-      } else {
-        log("WARNING: Could not access bbNativePlayerViewController to set goingFullScreen flag", level: .warning)
+        log("Set goingFullScreen = true on BBNativePlayerViewController", level: .info)
       }
     }
 
-    // iOS SDK Note: The iOS SDK uses enterFullScreen() method
-    playerController.playerView?.player.enterFullScreen()
+    playerView?.player.enterFullScreen()
 
-    // For landscape mode, force rotation after fullscreen is presented
     if forceLandscape {
-      // Use a small delay to ensure fullscreen modal is presented before rotating
       DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
         if #available(iOS 16.0, *) {
           if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
             windowScene.requestGeometryUpdate(.iOS(interfaceOrientations: .landscape))
             log("Requested landscape rotation", level: .info)
-
-            // Also update the supported orientations for the fullscreen view controller
-            if let playerView = self?.playerController.playerView?.player as? NSObject {
-              if let bbViewController = playerView.value(forKey: "bbNativePlayerViewController") as? NSObject {
-                if let avPlayerVC = bbViewController.value(forKey: "avPlayerViewController") as? UIViewController {
-                  avPlayerVC.setNeedsUpdateOfSupportedInterfaceOrientations()
-                  log("Updated supported orientations for AVPlayerViewController", level: .info)
-                }
-              }
-            }
           }
-        } else {
-          log("WARNING: requestGeometryUpdate requires iOS 16+, landscape rotation not available", level: .warning)
         }
       }
     }
   }
 
   func exitFullscreen() {
-    // iOS SDK Note: The iOS SDK uses exitFullScreen() method
-    // Orientation reset is handled by BBPlayerViewController.bbNativePlayerView(didTriggerRetractFullscreen:)
-    // to avoid duplicate orientation update calls which cause unnecessary CPU/GPU work
-    playerController.playerView?.player.exitFullScreen()
+    playerView?.player.exitFullScreen()
   }
 
   func destroy() {
-    // iOS SDK Note: The iOS SDK doesn't have a destroy() method
-    // The player is automatically cleaned up when the view is removed
+    // iOS SDK cleans up automatically when view is removed
   }
 
   func pause() {
-    playerController.playerView?.player.pause()
+    playerView?.player.pause()
   }
 
   func play() {
-    playerController.playerView?.player.play()
+    playerView?.player.play()
   }
 
   func seek(_ offsetInSeconds: Int) {
-    playerController.playerView?.player.seek(offsetInSeconds: offsetInSeconds as NSNumber)
+    playerView?.player.seek(offsetInSeconds: offsetInSeconds as NSNumber)
   }
 
   func seekRelative(_ offsetInSeconds: Double) {
-    // Use the shared time calculation helper
     let currentTime = calculateCurrentTime()
-
-    // Calculate new position and clamp to valid range [0, duration]
     let newPosition = max(0, min(currentDuration, currentTime + offsetInSeconds))
-
-    // Seek to the new position using the standard seek method
-    playerController.playerView?.player.seek(offsetInSeconds: newPosition as NSNumber)
+    playerView?.player.seek(offsetInSeconds: newPosition as NSNumber)
   }
 
   func setMuted(_ muted: Bool) {
-    // Call setApiProperty directly to match setVolume pattern
-    playerController.playerView?.setApiProperty(property: .muted, value: muted)
+    playerView?.setApiProperty(property: .muted, value: muted)
   }
 
   func setVolume(_ volume: Double) {
-    // Call setApiProperty directly with Float to avoid Double->Float cast crash in SDK
-    playerController.playerView?.setApiProperty(property: .volume, value: Float(volume))
+    playerView?.setApiProperty(property: .volume, value: Float(volume))
   }
 
   func loadWithClipId(_ clipId: String, initiator: String?, autoPlay: Bool?, seekTo: Double?) {
-    playerController.playerView?.player.loadWithClipId(clipId: clipId, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
+    playerView?.player.loadWithClipId(clipId: clipId, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
   }
 
   func loadWithClipListId(_ clipListId: String, initiator: String?, autoPlay: Bool?, seekTo: Double?) {
-    playerController.playerView?.player.loadWithClipListId(clipListId: clipListId, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
+    playerView?.player.loadWithClipListId(clipListId: clipListId, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
   }
 
   func loadWithProjectId(_ projectId: String, initiator: String?, autoPlay: Bool?, seekTo: Double?) {
-    playerController.playerView?.player.loadWithProjectId(projectId: projectId, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
+    playerView?.player.loadWithProjectId(projectId: projectId, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
   }
 
   func loadWithClipJson(_ clipJson: String, initiator: String?, autoPlay: Bool?, seekTo: Double?) {
-    playerController.playerView?.player.loadWithClipJson(clipJson: clipJson, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
+    playerView?.player.loadWithClipJson(clipJson: clipJson, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
   }
 
   func loadWithClipListJson(_ clipListJson: String, initiator: String?, autoPlay: Bool?, seekTo: Double?) {
-    playerController.playerView?.player.loadWithClipListJson(clipListJson: clipListJson, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
+    playerView?.player.loadWithClipListJson(clipListJson: clipListJson, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
   }
 
   func loadWithProjectJson(_ projectJson: String, initiator: String?, autoPlay: Bool?, seekTo: Double?) {
-    playerController.playerView?.player.loadWithProjectJson(projectJson: projectJson, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
-  }
+    playerView?.player.loadWithProjectJson(projectJson: projectJson, initiator: initiator, autoPlay: autoPlay, seekTo: seekTo as NSNumber?)
+  }
+
+  /**
+   * Load content from a JSON URL into the existing player.
+   * Extracts IDs from the URL and uses the native SDK's loadWithXxxId methods.
+   * This is more reliable than parsing JSON because the SDK handles all the loading internally.
+   *
+   * Note: Shorts URLs (/sh/{id}.json) are NOT supported here - use BBShortsView instead.
+   */
+  func loadWithJsonUrl(_ url: String, autoPlay: Bool) {
+    NSLog("BBPlayerView.loadWithJsonUrl called - url: %@, autoPlay: %d", url, autoPlay)
+    guard playerView != nil else {
+      NSLog("BBPlayerView.loadWithJsonUrl ERROR - playerView not initialized")
+      return
+    }
+
+    NSLog("BBPlayerView.loadWithJsonUrl - playerView exists, parsing URL")
+
+    // Extract ID from URL patterns like:
+    // /c/{id}.json or /mediaclip/{id}.json -> clip ID
+    // /l/{id}.json or /mediacliplist/{id}.json -> clip list ID
+    // /pj/{id}.json or /project/{id}.json -> project ID
+
+    let clipIdPattern = "/c/([0-9]+)\\.json|/mediaclip/([0-9]+)"
+    let clipListIdPattern = "/l/([0-9]+)\\.json|/mediacliplist/([0-9]+)"
+    let projectIdPattern = "/pj/([0-9]+)\\.json|/project/([0-9]+)"
+    let shortsIdPattern = "/sh/([0-9]+)\\.json"
+
+    if let shortsMatch = url.range(of: shortsIdPattern, options: .regularExpression) {
+      // Shorts require a separate BBShortsView component
+      log("ERROR - Shorts URLs are not supported in BBPlayerView. Use BBShortsView instead.", level: .error)
+      onDidFailWithError?(["payload": "Shorts URLs are not supported in BBPlayerView. Use BBShortsView instead."])
+      return
+    }
+
+    if let match = url.range(of: clipListIdPattern, options: .regularExpression) {
+      // Extract the cliplist ID
+      if let clipListId = extractIdFromUrl(url, pattern: clipListIdPattern) {
+        NSLog("BBPlayerView.loadWithJsonUrl - Loading ClipList by ID: %@", clipListId)
+        playerView?.player.loadWithClipListId(clipListId: clipListId, initiator: "external", autoPlay: autoPlay, seekTo: nil)
+      } else {
+        NSLog("BBPlayerView.loadWithJsonUrl ERROR - Failed to extract cliplist ID from URL: %@", url)
+      }
+      return
+    }
 
-  // Note: loadWithShortsId is NOT supported on BBPlayerView.
-  // For Shorts playback, use the BBShortsView component instead.
+    if let match = url.range(of: projectIdPattern, options: .regularExpression) {
+      // Extract the project ID
+      if let projectId = extractIdFromUrl(url, pattern: projectIdPattern) {
+        NSLog("BBPlayerView.loadWithJsonUrl - Loading Project by ID: %@", projectId)
+        playerView?.player.loadWithProjectId(projectId: projectId, initiator: "external", autoPlay: autoPlay, seekTo: nil)
+      } else {
+        NSLog("BBPlayerView.loadWithJsonUrl ERROR - Failed to extract project ID from URL: %@", url)
+      }
+      return
+    }
+
+    if let match = url.range(of: clipIdPattern, options: .regularExpression) {
+      // Extract the clip ID
+      if let clipId = extractIdFromUrl(url, pattern: clipIdPattern) {
+        NSLog("BBPlayerView.loadWithJsonUrl - Loading Clip by ID: %@", clipId)
+        playerView?.player.loadWithClipId(clipId: clipId, initiator: "external", autoPlay: autoPlay, seekTo: nil)
+      } else {
+        NSLog("BBPlayerView.loadWithJsonUrl ERROR - Failed to extract clip ID from URL: %@", url)
+      }
+      return
+    }
+
+    NSLog("BBPlayerView.loadWithJsonUrl ERROR - Unknown URL format, cannot extract ID: %@", url)
+    onDidFailWithError?(["payload": "Cannot load content: unsupported URL format"])
+  }
+
+  /**
+   * Helper to extract numeric ID from URL using regex pattern with capture groups
+   */
+  private func extractIdFromUrl(_ url: String, pattern: String) -> String? {
+    do {
+      let regex = try NSRegularExpression(pattern: pattern, options: [])
+      let range = NSRange(url.startIndex..., in: url)
+      if let match = regex.firstMatch(in: url, options: [], range: range) {
+        // Try each capture group (pattern has multiple alternatives with |)
+        for i in 1..<match.numberOfRanges {
+          if let groupRange = Range(match.range(at: i), in: url) {
+            let extracted = String(url[groupRange])
+            if !extracted.isEmpty {
+              return extracted
+            }
+          }
+        }
+      }
+    } catch {
+      log("ERROR - Regex error: \(error)", level: .error)
+    }
+    return nil
+  }
 
   func showCastPicker() {
     log("showCastPicker called")
 
-    // CRITICAL: Verify Google Cast SDK is initialized before proceeding
     if !GCKCastContext.isSharedInstanceInitialized() {
       log("ERROR - showCastPicker called but Google Cast SDK not initialized yet", level: .error)
       return
     }
 
-    // Create the button lazily if it doesn't exist yet
     if independentCastButton == nil {
       setupIndependentCastButton()
     }
@@ -734,8 +839,6 @@ class BBPlayerView: UIView, BBPlayerViewControllerDelegate {
       return
     }
 
-    // Trigger the independent cast button to show the cast device picker
-    // This works with the SDK because they both use the shared GCKSessionManager
     DispatchQueue.main.async {
       log("showCastPicker triggering independent GCKUICastButton")
       castButton.sendActions(for: .touchUpInside)