@volcengine/react-native-live-pull 1.1.3-rc.1 → 1.2.0-rc.1

package/ios/pictureInpicture/PictureInPictureManager.m

@@ -1,26 +1,29 @@
 #import "PictureInPictureManager.h"
 #import "../VeLivePlayerMultiObserver.h"
-#import "TTSDKFramework/TVLManager.h"
-#import "VeLivePictureInPictureController.h"
 #import <AVKit/AVKit.h>
+#import <TTSDKFramework/TTVideoLive.h>
 #import <UIKit/UIKit.h>
+#import <VolcApiEngine/VePictureInPictureController.h>
+#import <VolcApiEngine/VePictureInPictureDefine.h>
 
 @protocol VeLivePlayerObserver;
-@protocol VeLivePictureInPictureDelegate;
+@protocol VePictureInPictureDelegate;
 @protocol VeLivePictureInPictureManagerListener;
 
 // Add class extension to declare private properties instead of redefining
 // interface
 @interface VeLivePictureInPictureManager () <
-    VeLivePlayerObserver, VeLivePictureInPictureDelegate,
+    VeLivePlayerObserver, VePictureInPictureDelegate,
     VeLivePictureInPictureManagerListener>
-@property(nonatomic, strong) VeLivePictureInPictureController *pipController;
-@property(nonatomic, assign) CGRect pipVideoFrame;
-@property(nonatomic, assign) CGSize pipVideoSize;
+@property(nonatomic, strong) VePictureInPictureController *pipController;
 @property(nonatomic, assign) BOOL enableVideoObserver;
 @property(nonatomic, strong) TVLManager *player;
+@property(nonatomic, weak) UIView *contentView;
 @property(nonatomic, weak) id<VeLivePictureInPictureManagerListener> listener;
 @property(nonatomic, assign) BOOL pipAutoStart;
+@property(nonatomic, strong)
+    NSMutableDictionary<NSString *, void (^)(AVPictureInPictureController *)>
+        *pipObservers;
 @end
 
 NSString *const kObserverKey = @"pip-observer";
@@ -40,45 +43,157 @@ NSString *const kObserverKey = @"pip-observer";
   return [self sharedInstance];
 }
 
-- (void)setupPlayer:(TVLManager *)player {
-  if (self.player) {
-    [self destroyPictureInPicture];
+- (instancetype)init {
+  if (self = [super init]) {
+    _autoHideViewController = YES;
+    _pipObservers = [NSMutableDictionary dictionary];
+    if (@available(iOS 14.2, *)) {
+      _canStartPictureInPictureAutomaticallyFromInline = NO;
+    }
   }
-  self.player = player;
+  return self;
+}
 
-  // Reset video frame observer status
-  self.enableVideoObserver = NO;
-  self.pipAutoStart = NO;
+- (void)dealloc {
+  [self disableVideoFrameObserver];
+
+  if (self.pipController) {
+    self.pipController.delegate = nil;
+    self.pipController = nil;
+  }
+
+  [[VeLivePlayerMultiObserver sharedInstance] removeObserver:kObserverKey];
+}
+
+- (void)setupPlayer:(TVLManager *)player {
+  [self ensurePipControllerReady:player completion:nil];
 }
 
-- (void)setupPictureInPicturePrepareCompletion:
-    (VELPipPrepareCompletionBlock)prepareCompletion {
+- (void)ensurePipControllerReady:(TVLManager *)player
+                      completion:(nullable void (^)(void))completion {
+  if (player && self.player != player) {
+    if (self.player) {
+      [self disableVideoFrameObserver];
+    }
+    self.player = player;
+    self.contentView = player.playerView;
+  }
+
   if (!self.pipController) {
-    self.pipController = [[VeLivePictureInPictureController alloc]
-        initWithType:VeLivePictureInPictureTypeAuto
-         contentView:self.player.playerView];
-    [self setupPipVideoFrameAndSize];
-    self.pipController.delegate = self;
-    self.pipController.contentController = nil;
-    self.pipController.autoHideContentController = NO;
-    if (@available(iOS 14.0, *)) {
-      self.player.supportPictureInPictureMode = YES;
+    [self initPipController];
+    [self enableVideoFrameObserver];
+    [self updatePipController:completion];
+  }
+
+  if (self.contentView && self.pipController) {
+    if (@available(iOS 14.2, *)) {
+      self.pipController.canStartPictureInPictureAutomaticallyFromInline =
+          self.canStartPictureInPictureAutomaticallyFromInline;
+    }
+    [self updatePipController:completion];
+  } else {
+    if (completion) {
+      completion();
     }
   }
-  [self.pipController prepareWithCompletion:prepareCompletion];
 }
 
-- (void)setupPipVideoFrameAndSize {
-  if (!CGSizeEqualToSize(self.pipVideoSize, CGSizeZero)) {
-    [self.pipController setVideoSize:self.pipVideoSize];
+// Add a persistent observer for PIP controller status, returns observer ID
+- (NSString *)addPipControllerObserver:
+    (void (^)(AVPictureInPictureController *pipController))observer {
+  if (!observer) {
+    return nil;
   }
-  if (!CGRectEqualToRect(self.pipVideoFrame, CGRectZero)) {
-    [self.pipController setVideoFrame:self.pipVideoFrame];
+
+  NSString *observerId = [NSString
+      stringWithFormat:@"observer_%@_%lu", [[NSUUID UUID] UUIDString],
+                       (unsigned long)[NSDate date].timeIntervalSince1970];
+
+  self.pipObservers[observerId] = observer;
+
+  // If PIP controller is already ready, notify immediately
+  if (self.pipController) {
+    observer([self.pipController pictureInPictureController]);
+  }
+
+  return observerId;
+}
+
+// Remove observer by ID
+- (void)removePipControllerObserver:(NSString *)observerId {
+  if (observerId) {
+    [self.pipObservers removeObjectForKey:observerId];
+  }
+}
+
+// Remove all observers
+- (void)removeAllPipControllerObservers {
+  [self.pipObservers removeAllObjects];
+}
+
+- (void)initPipController {
+  if (self.pipController != nil) {
+    self.pipController.delegate = nil;
+    self.pipController = nil;
+  }
+  self.pipController = [[VePictureInPictureController alloc]
+      initWithType:VePictureInPictureTypeContentSource
+       contentView:self.player.playerView];
+  [self.pipController setRenderMode:1];
+  self.pipController.delegate = self;
+  self.pipController.autoConfigAudioSession = YES;
+  if (@available(iOS 14.2, *)) {
+    self.pipController.canStartPictureInPictureAutomaticallyFromInline =
+        self.canStartPictureInPictureAutomaticallyFromInline;
+  }
+  if (@available(iOS 14.0, *)) {
+    self.pipController.requiresLinearPlayback = NO;
+  }
+
+  if (self.pipObservers.count > 0) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self notifyPipControllerReady];
+    });
+  }
+}
+
+- (void)updatePipController:(nullable void (^)(void))completion {
+  VeLivePlayerVideoStreamInfo *info = [self.player getVideoStreamInfo];
+  
+  if (!CGSizeEqualToSize(CGSizeZero, CGSizeMake(info.width, info.height))) {
+    [self.pipController setVideoSize:CGSizeMake(info.width, info.height) completion:nil];    
+  }
+
+  [self.pipController setContentView:self.contentView
+                          completion:^{
+                            if (completion) {
+                              completion();
+                            }
+                          }];  
+}
+
+// Notify all observers
+- (void)notifyPipControllerReady {
+  if (!self.pipController) {
+    return;
+  }
+
+  AVPictureInPictureController *controller =
+      [self.pipController pictureInPictureController];
+
+  // copy observers to avoid modifying the dictionary while iterating
+  NSDictionary *observersCopy = [self.pipObservers copy];
+
+  // Notify all persistent observers
+  for (void (^observer)(AVPictureInPictureController *)
+           in observersCopy.allValues) {
+    if (observer) {
+      observer(controller);
+    }
   }
 }
 
 - (void)enableVideoFrameObserver {
-  NSLog(@"PIP: Enable video frame observer");
   if (self.enableVideoObserver) {
     // If already enabled, disable then re-enable to ensure the observer is
     // re-registered
@@ -89,11 +204,12 @@ NSString *const kObserverKey = @"pip-observer";
       enableVideoFrameObserver:YES
                    pixelFormat:VeLivePlayerPixelFormatBGRA32
                     bufferType:VeLivePlayerVideoBufferTypeSampleBuffer];
-  NSLog(@"PIP: Video frame observer enabled");
+  [[VeLivePlayerMultiObserver sharedInstance] removeObserver:kObserverKey];
+  [[VeLivePlayerMultiObserver sharedInstance] addObserver:kObserverKey
+                                                 observer:self];
 }
 
 - (void)disableVideoFrameObserver {
-  NSLog(@"PIP: Disable video frame observer");
   if (!self.enableVideoObserver) {
     return;
   }
@@ -101,94 +217,86 @@ NSString *const kObserverKey = @"pip-observer";
   [self.player enableVideoFrameObserver:NO
                             pixelFormat:VeLivePlayerPixelFormatUnknown
                              bufferType:VeLivePlayerVideoBufferTypeUnknown];
-  NSLog(@"PIP: Video frame observer disabled");
+  [[VeLivePlayerMultiObserver sharedInstance] removeObserver:kObserverKey];
 }
 
 - (void)startPictureInPicture {
-  NSLog(@"PIP: Start picture-in-picture");
-  [self enableVideoFrameObserver];
-
-  // Ensure observer is properly added
-  [[VeLivePlayerMultiObserver sharedInstance] removeObserver:kObserverKey];
-  [[VeLivePlayerMultiObserver sharedInstance] addObserver:kObserverKey
-                                                 observer:self];
+  if (!self.player) {
+    return;
+  }
 
-  // Use main thread with delay to ensure state is updated
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [self setupPictureInPicturePrepareCompletion:^(
-              VeLivePictureInPictureController *_Nonnull pipController,
-              NSError *_Nullable error) {
-      if (error != nil) {
-        NSLog(@"PIP: Failed to start picture-in-picture: %@", error);
-        return;
-      }
-      if (!self.player.isPlaying) {
-        NSLog(@"PIP: Please start playing before entering PIP mode");
-        return;
-      }
-      if (!self.pipController.canStartPictureInPicture) {
-        NSLog(@"PIP: Cannot start picture-in-picture now, please try again "
-              @"later");
-        return;
-      }
-      NSLog(@"PIP: Ready to start picture-in-picture");
-      [self.pipController startPictureInPicture];
-    }];
-  });
+  [self ensurePipControllerReady:self.player
+                      completion:^{
+                        if (@available(iOS 14.0, *)) {
+                          [self.player setSupportPictureInPictureMode:YES];
+                          BOOL startSuccess =
+                              [self.pipController startPictureInPicture];
+                          if (!startSuccess) {
+                            NSLog(@"PIP: Failed to start picture-in-picture");
+                          }
+                        }
+                      }];
 }
 
 - (void)stopPictureInPicture {
-  [self disableVideoFrameObserver];
-  [[VeLivePlayerMultiObserver sharedInstance] removeObserver:kObserverKey];
-  [self.pipController stopPictureInPicture];
+  if (self.autoHideViewController) {
+    [self.pipController
+        stopPictureInPictureWithType:VePictureInPictureStopTypeFromApiRestore];
+  } else {
+    [self.pipController stopPictureInPicture];
+  }
 }
 
 - (void)destroyPictureInPicture {
   dispatch_async(dispatch_get_main_queue(), ^{
+    [self stopPictureInPicture];
+
+    // ensure this is called on the main thread
     [self disableVideoFrameObserver];
-    [self.pipController destroyPictureInPicture];
-    [self setPipController:nil];
-    [[VeLivePlayerMultiObserver sharedInstance] removeObserver:kObserverKey];
-    self.player = nil;
+
+    // clear delegate to avoid retain cycle
+    if (self.pipController) {
+      self.pipController.delegate = nil;
+    }
+
+    self.pipController = nil;
+
+    if (@available(iOS 14.2, *)) {
+      [self setCanStartPictureInPictureAutomaticallyFromInline:NO];
+    }
   });
 }
 
 - (BOOL)isPictureInPictureStarted {
-  return VeLivePictureInPictureController.isPictureInPictureStarted;
+  return [VePictureInPictureController isPictureInPictureStarted];
 }
 
 - (BOOL)isPictureInPictureSupported {
-  return [VeLivePictureInPictureController isPictureInPictureSupported];
+  return [VePictureInPictureController isPictureInPictureSupported];
 }
 
 - (void)enablePictureInPicture {
-  NSLog(@"PIP: Enable picture-in-picture");
-  self.pipAutoStart = YES;
-  // main thread
+  _canStartPictureInPictureAutomaticallyFromInline = YES;
+  if (self.pipController != nil) {
+    if (@available(iOS 14.2, *)) {
+      self.pipController.canStartPictureInPictureAutomaticallyFromInline = YES;
+    }
+  }
   dispatch_async(dispatch_get_main_queue(), ^{
     if (@available(iOS 14.2, *)) {
-      [self setupPictureInPicturePrepareCompletion:^(
-                VeLivePictureInPictureController *_Nonnull pipController,
-                NSError *_Nullable error) {
-        // Set in callback to ensure controller is ready
-        [pipController setCanStartPictureInPictureAutomaticallyFromInline:YES];
-      }];
+      [self ensurePipControllerReady:self.player completion:nil];
     }
   });
 }
 
 - (void)disablePictureInPicture {
-  NSLog(@"PIP: Disable picture-in-picture");
-  self.pipAutoStart = NO;
-  if (!self.pipController) {
-    return;
+  _canStartPictureInPictureAutomaticallyFromInline = NO;
+  if (self.pipController != nil) {
+    self.pipController.canStartPictureInPictureAutomaticallyFromInline = NO;
   }
   dispatch_async(dispatch_get_main_queue(), ^{
     if (@available(iOS 14.2, *)) {
-      [self.pipController
-          setCanStartPictureInPictureAutomaticallyFromInline:NO];
-      [self.pipController destroyPictureInPicture];
-      self.pipController = nil;
+      [self destroyPictureInPicture];
     }
   });
 }
@@ -201,73 +309,84 @@ NSString *const kObserverKey = @"pip-observer";
 - (void)onRenderVideoFrame:(TVLManager *_Nonnull)player
                 videoFrame:(VeLivePlayerVideoFrame *_Nonnull)videoFrame {
   @autoreleasepool {
+    // 确保 pipController 存在且有效，避免在销毁过程中继续处理 buffer
+    if (!self.pipController || !self.enableVideoObserver) {
+      return;
+    }
+
     if (@available(iOS 15.0, *)) {
       if (videoFrame.bufferType == VeLivePlayerVideoBufferTypePixelBuffer) {
-        [self.pipController enqueuePixelBuffer:videoFrame.pixelBuffer];
+        CVPixelBufferRef pixelBuffer = videoFrame.pixelBuffer;
+        if (pixelBuffer != NULL) {
+          [self.pipController enqueuePixelBuffer:pixelBuffer];
+        }
       } else if (videoFrame.bufferType ==
                  VeLivePlayerVideoBufferTypeSampleBuffer) {
-        [self.pipController enqueueSampleBuffer:videoFrame.sampleBuffer];
+        CMSampleBufferRef sampleBuffer = videoFrame.sampleBuffer;
+        if (sampleBuffer != NULL) {
+          [self.pipController enqueueSampleBuffer:sampleBuffer];
+        }
       }
     }
   }
 }
 
-- (void)onVideoSizeChanged:(TVLManager *)player
-                     width:(int)width
-                    height:(int)height {
-  self.pipVideoSize = CGSizeMake(width, height);
-  if (!CGSizeEqualToSize(CGSizeZero, player.videoAreaFrame.size)) {
-    self.pipVideoFrame = player.videoAreaFrame;
-  } else {
-    self.pipVideoFrame = player.playerView.frame;
-  }
-  [self setupPipVideoFrameAndSize];
-}
-
 - (void)onError:(TVLManager *)player error:(VeLivePlayerError *)error {
   NSLog(@"VeLiveQuickStartDemo: Error %ld, %@", error.code, error.errorMsg);
 }
 
-/// MARK: - VeLivePictureInPictureDelegate
-- (void)pictureInPictureIsReady:
-    (VeLivePictureInPictureController *)pictureInPicture {
-  NSLog(@"PIP: Picture-in-picture is ready");
-}
+/// MARK: - VePictureInPictureDelegate
+- (void)pictureInPictureController:
+            (VePictureInPictureController *)pictureInPictureController
+                     statusChanged:(VePictureInPictureStatus)fromStatus
+                                to:(VePictureInPictureStatus)toStatus {
+  switch (toStatus) {
+  case VePictureInPictureStatusIde: {
 
-- (void)pictureInPictureWillStart:
-    (VeLivePictureInPictureController *)pictureInPicture {
-  NSLog(@"PIP: Picture-in-picture will start...");
-}
+  } break;
+  case VePictureInPictureStatusPreparing: {
 
-- (void)pictureInPictureDidStart:
-    (VeLivePictureInPictureController *)pictureInPicture {
-  NSLog(@"PIP: Picture-in-picture did start");
-  if (self.listener) {
-    [self.listener onStartPictureInPicture];
-  }
-}
-- (void)pictureInPicture:(VeLivePictureInPictureController *)pictureInPicture
-    failedToStartWithError:(NSError *)error {
-  NSLog(@"PIP: Failed to start picture-in-picture: %@", error);
-  if (self.listener) {
-    [self.listener onError:error.code extraData:error.userInfo];
-  }
-}
-- (void)pictureInPictureWillStop:
-            (VeLivePictureInPictureController *)pictureInPicture
-                      isUserStop:(BOOL)isUserStop {
-  NSLog(@"PIP: Picture-in-picture will stop");
-}
-- (void)pictureInPictureDidStop:
-            (VeLivePictureInPictureController *)pictureInPicture
-                     isUserStop:(BOOL)isUserStop {
-  NSLog(@"PIP: Picture-in-picture stopped");
-  if (self.listener) {
-    [self.listener onStopPictureInPicture];
+  } break;
+  case VePictureInPictureStatusReady: {
+    [self notifyPipControllerReady];
+  } break;
+  case VePictureInPictureStatusWillStart: {
+
+  } break;
+  case VePictureInPictureStatusDidStart: {
+    if (self.listener) {
+      [self.listener onStartPictureInPicture];
+    }
+    break;
+  case VePictureInPictureStatusWillChange: {
+
+  } break;
+  case VePictureInPictureStatusDidChange: {
+
+  } break;
+  case VePictureInPictureStatusRestoreUI: {
+
+  } break;
+  case VePictureInPictureStatusWillStop: {
+
+  } break;
+  case VePictureInPictureStatusDidStop: {
+    if (self.listener) {
+      [self.listener onStopPictureInPicture];
+    }
+    if (@available(iOS 14.2, *)) {
+      if (!self.canStartPictureInPictureAutomaticallyFromInline) {
+        [self destroyPictureInPicture];
+      }
+    }
+  } break;
+  case VePictureInPictureStatusError: {
+    if (self.listener) {
+      [self.listener onError:pictureInPictureController.error.code
+                   extraData:pictureInPictureController.error.userInfo];
+    }
+  } break;
   }
-  if (!self.pipAutoStart) {
-    [self.pipController destroyPictureInPicture];
-    self.pipController = nil;
   }
 }