@volcengine/react-native-live-pull 1.0.3-rc.0 → 1.1.1-rc.0

package/ios/VeLivePlayerMultiObserver.m

@@ -0,0 +1,324 @@
+#import "VeLivePlayerMultiObserver.h"
+#import "TTSDKFramework/TVLManager.h"
+
+@interface VeLivePlayerMultiObserver ()
+@property(nonatomic, strong) NSMutableDictionary *observerDict;
+@property(nonatomic, strong) dispatch_queue_t observerQueue;
+@property(nonatomic, strong) TVLManager *player;
+@end
+
+@implementation VeLivePlayerMultiObserver
+
+// 单例实现
++ (instancetype)sharedInstance {
+  static VeLivePlayerMultiObserver *instance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    instance = [[self alloc] init];
+  });
+  return instance;
+}
+
++ (instancetype)getInstance {
+  return [self sharedInstance];
+}
+
+// 初始化方法
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _observerDict = [NSMutableDictionary dictionary];
+    _observerQueue = dispatch_queue_create("com.velive.player.multiobserver",
+                                           DISPATCH_QUEUE_SERIAL);
+  }
+  return self;
+}
+
+- (void)setupPlayer:(TVLManager *)player {
+  if(self.player) {
+    [self clearObservers];
+  }
+  self.player = player;
+  [player setObserver:self];
+}
+
+// 添加观察者到字典中
+- (void)addObserver:(NSString *)observerId
+           observer:(id<VeLivePlayerObserver>)observer {
+  if (!observer || !observerId) {
+    return;
+  }
+
+  dispatch_sync(self.observerQueue, ^{
+    [self.observerDict setObject:observer forKey:observerId];
+  });
+}
+
+// 从字典中移除观察者
+- (void)removeObserver:(NSString *)observerId {
+  if (!observerId) {
+    return;
+  }
+
+  dispatch_sync(self.observerQueue, ^{
+    [self.observerDict removeObjectForKey:observerId];
+  });
+}
+
+// 获取所有观察者
+- (NSArray *)getObservers {
+  __block NSArray *result = nil;
+  dispatch_sync(self.observerQueue, ^{
+    result = [self.observerDict allValues];
+  });
+  return result;
+}
+
+// 清空所有观察者
+- (void)clearObservers {
+  dispatch_sync(self.observerQueue, ^{
+    [self.observerDict removeAllObjects];
+  });
+}
+
+#pragma mark - VeLivePlayerObserver 方法实现
+
+// 直接实现所有 VeLivePlayerObserver 协议方法，而不是依赖消息转发
+
+- (void)onError:(TVLManager *)player error:(VeLivePlayerError *)error {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onError:error:)]) {
+      [observer onError:player error:error];
+    }
+  }
+}
+
+- (void)onFirstVideoFrameRender:(TVLManager *)player
+                   isFirstFrame:(BOOL)isFirstFrame {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onFirstVideoFrameRender:
+                                                          isFirstFrame:)]) {
+      [observer onFirstVideoFrameRender:player isFirstFrame:isFirstFrame];
+    }
+  }
+}
+
+- (void)onFirstAudioFrameRender:(TVLManager *)player
+                   isFirstFrame:(BOOL)isFirstFrame {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onFirstAudioFrameRender:
+                                                          isFirstFrame:)]) {
+      [observer onFirstAudioFrameRender:player isFirstFrame:isFirstFrame];
+    }
+  }
+}
+
+- (void)onStallStart:(TVLManager *)player {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onStallStart:)]) {
+      [observer onStallStart:player];
+    }
+  }
+}
+
+- (void)onStallEnd:(TVLManager *)player {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onStallEnd:)]) {
+      [observer onStallEnd:player];
+    }
+  }
+}
+
+- (void)onVideoRenderStall:(TVLManager *)player stallTime:(int64_t)stallTime {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onVideoRenderStall:
+                                                        stallTime:)]) {
+      [observer onVideoRenderStall:player stallTime:stallTime];
+    }
+  }
+}
+
+- (void)onAudioRenderStall:(TVLManager *)player stallTime:(int64_t)stallTime {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onAudioRenderStall:
+                                                        stallTime:)]) {
+      [observer onAudioRenderStall:player stallTime:stallTime];
+    }
+  }
+}
+
+- (void)onResolutionSwitch:(TVLManager *)player
+                resolution:(VeLivePlayerResolution)resolution
+                     error:(VeLivePlayerError *)error
+                    reason:(VeLivePlayerResolutionSwitchReason)reason {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector
+                  (onResolutionSwitch:resolution:error:reason:)]) {
+      [observer onResolutionSwitch:player
+                        resolution:resolution
+                             error:error
+                            reason:reason];
+    }
+  }
+}
+
+- (void)onVideoSizeChanged:(TVLManager *)player
+                     width:(int)width
+                    height:(int)height {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onVideoSizeChanged:
+                                                            width:height:)]) {
+      [observer onVideoSizeChanged:player width:width height:height];
+    }
+  }
+}
+
+- (void)onReceiveSeiMessage:(TVLManager *)player message:(NSString *)message {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onReceiveSeiMessage:message:)]) {
+      [observer onReceiveSeiMessage:player message:message];
+    }
+  }
+}
+
+- (void)onMainBackupSwitch:(TVLManager *)player
+                streamType:(VeLivePlayerStreamType)streamType
+                     error:(VeLivePlayerError *)error {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onMainBackupSwitch:
+                                                       streamType:error:)]) {
+      [observer onMainBackupSwitch:player streamType:streamType error:error];
+    }
+  }
+}
+
+- (void)onPlayerStatusUpdate:(TVLManager *)player
+                      status:(VeLivePlayerStatus)status {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onPlayerStatusUpdate:status:)]) {
+      [observer onPlayerStatusUpdate:player status:status];
+    }
+  }
+}
+
+- (void)onStatistics:(TVLManager *)player
+          statistics:(VeLivePlayerStatistics *)statistics {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onStatistics:statistics:)]) {
+      [observer onStatistics:player statistics:statistics];
+    }
+  }
+}
+
+- (void)onSnapshotComplete:(TVLManager *)player image:(UIImage *)image {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onSnapshotComplete:image:)]) {
+      [observer onSnapshotComplete:player image:image];
+    }
+  }
+}
+
+- (void)onRenderVideoFrame:(TVLManager *)player
+                videoFrame:(VeLivePlayerVideoFrame *)videoFrame {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onRenderVideoFrame:
+                                                       videoFrame:)]) {
+      // 跳过 rn-observer，只转发给其他观察者（如 pip-observer）
+      NSString *observerId = nil;
+      for (NSString *key in self.observerDict) {
+        if ([self.observerDict objectForKey:key] == observer) {
+          observerId = key;
+          break;
+        }
+      }
+
+      // 如果观察者ID包含 "rn"，则跳过帧处理
+      if (observerId && [observerId containsString:@"rn"]) {
+        continue;
+      }
+
+      [observer onRenderVideoFrame:player videoFrame:videoFrame];
+    }
+  }
+}
+
+- (void)onRenderAudioFrame:(TVLManager *)player
+                audioFrame:(VeLivePlayerAudioFrame *)audioFrame {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector(onRenderAudioFrame:
+                                                       audioFrame:)]) {
+      // 跳过 rn-observer，只转发给其他观察者
+      NSString *observerId = nil;
+      for (NSString *key in self.observerDict) {
+        if ([self.observerDict objectForKey:key] == observer) {
+          observerId = key;
+          break;
+        }
+      }
+
+      // 如果观察者ID包含 "rn"，则跳过帧处理
+      if (observerId && [observerId containsString:@"rn"]) {
+        continue;
+      }
+
+      [observer onRenderAudioFrame:player audioFrame:audioFrame];
+    }
+  }
+}
+
+- (void)onStreamFailedOpenSuperResolution:(TVLManager *)player
+                                    error:(VeLivePlayerError *)error {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector
+                  (onStreamFailedOpenSuperResolution:error:)]) {
+      [observer onStreamFailedOpenSuperResolution:player error:error];
+    }
+  }
+}
+
+- (NSData *)getDrmResourceLoaderCertificateData:(TVLManager *)player {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer respondsToSelector:@selector
+                  (getDrmResourceLoaderCertificateData:)]) {
+      NSData *data = [observer getDrmResourceLoaderCertificateData:player];
+      if (data) {
+        return data;
+      }
+    }
+  }
+  return nil;
+}
+
+- (NSString *)getDrmResourceLoaderLicenseUrl:(TVLManager *)player {
+  NSArray *observers = [self getObservers];
+  for (id<VeLivePlayerObserver> observer in observers) {
+    if ([observer
+            respondsToSelector:@selector(getDrmResourceLoaderLicenseUrl:)]) {
+      NSString *url = [observer getDrmResourceLoaderLicenseUrl:player];
+      if (url) {
+        return url;
+      }
+    }
+  }
+  return nil;
+}
+
+@end

package/ios/pictureInpicture/PictureInPictureManager.h

@@ -0,0 +1,29 @@
+#import <Foundation/Foundation.h>
+@class TVLManager;
+@class UIView;
+
+@protocol VeLivePictureInPictureManagerListener <NSObject>
+- (void)onStartPictureInPicture;
+- (void)onStopPictureInPicture;
+- (void)onClickPictureInPicture;
+- (void)onError:(NSInteger)code extraData:(NSDictionary *)extraData;
+@end
+
+@interface VeLivePictureInPictureManager : NSObject
+
+// Expose shared instance methods to RN
++ (instancetype)sharedInstance;
++ (instancetype)getInstance;
+
+// Expose other methods that need to be called from RN
+- (void)setupPlayer:(TVLManager *)player;
+- (void)enablePictureInPicture;
+- (void)disablePictureInPicture;
+- (void)startPictureInPicture;
+- (void)stopPictureInPicture;
+- (void)destroyPictureInPicture;
+- (BOOL)isPictureInPictureSupported;
+- (void)setListener:(id<VeLivePictureInPictureManagerListener>)listener;
+
+
+@end

package/ios/pictureInpicture/PictureInPictureManager.m

@@ -0,0 +1,274 @@
+#import "PictureInPictureManager.h"
+#import "../VeLivePlayerMultiObserver.h"
+#import "TTSDKFramework/TVLManager.h"
+#import "VeLivePictureInPictureController.h"
+#import <AVKit/AVKit.h>
+#import <UIKit/UIKit.h>
+
+@protocol VeLivePlayerObserver;
+@protocol VeLivePictureInPictureDelegate;
+@protocol VeLivePictureInPictureManagerListener;
+
+// Add class extension to declare private properties instead of redefining
+// interface
+@interface VeLivePictureInPictureManager () <
+    VeLivePlayerObserver, VeLivePictureInPictureDelegate,
+    VeLivePictureInPictureManagerListener>
+@property(nonatomic, strong) VeLivePictureInPictureController *pipController;
+@property(nonatomic, assign) CGRect pipVideoFrame;
+@property(nonatomic, assign) CGSize pipVideoSize;
+@property(nonatomic, assign) BOOL enableVideoObserver;
+@property(nonatomic, strong) TVLManager *player;
+@property(nonatomic, weak) id<VeLivePictureInPictureManagerListener> listener;
+@property(nonatomic, assign) BOOL pipAutoStart;
+@end
+
+NSString *const kObserverKey = @"pip-observer";
+
+@implementation VeLivePictureInPictureManager
+
++ (instancetype)sharedInstance {
+  static VeLivePictureInPictureManager *instance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    instance = [[self alloc] init];
+  });
+  return instance;
+}
+
++ (instancetype)getInstance {
+  return [self sharedInstance];
+}
+
+- (void)setupPlayer:(TVLManager *)player {
+  if (self.player) {
+    [self destroyPictureInPicture];
+  }
+  self.player = player;
+
+  // Reset video frame observer status
+  self.enableVideoObserver = NO;
+  self.pipAutoStart = NO;
+}
+
+- (void)setupPictureInPicturePrepareCompletion:
+    (VELPipPrepareCompletionBlock)prepareCompletion {
+  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.pipController prepareWithCompletion:prepareCompletion];
+}
+
+- (void)setupPipVideoFrameAndSize {
+  if (!CGSizeEqualToSize(self.pipVideoSize, CGSizeZero)) {
+    [self.pipController setVideoSize:self.pipVideoSize];
+  }
+  if (!CGRectEqualToRect(self.pipVideoFrame, CGRectZero)) {
+    [self.pipController setVideoFrame:self.pipVideoFrame];
+  }
+}
+
+- (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
+    [self disableVideoFrameObserver];
+  }
+  self.enableVideoObserver = YES;
+  [self.player
+      enableVideoFrameObserver:YES
+                   pixelFormat:VeLivePlayerPixelFormatBGRA32
+                    bufferType:VeLivePlayerVideoBufferTypeSampleBuffer];
+  NSLog(@"PIP: Video frame observer enabled");
+}
+
+- (void)disableVideoFrameObserver {
+  NSLog(@"PIP: Disable video frame observer");
+  if (!self.enableVideoObserver) {
+    return;
+  }
+  self.enableVideoObserver = NO;
+  [self.player enableVideoFrameObserver:NO
+                            pixelFormat:VeLivePlayerPixelFormatUnknown
+                             bufferType:VeLivePlayerVideoBufferTypeUnknown];
+  NSLog(@"PIP: Video frame observer disabled");
+}
+
+- (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];
+
+  // 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];
+    }];
+  });
+}
+
+- (void)stopPictureInPicture {
+  [self disableVideoFrameObserver];
+  [[VeLivePlayerMultiObserver sharedInstance] removeObserver:kObserverKey];
+  [self.pipController stopPictureInPicture];
+}
+
+- (void)destroyPictureInPicture {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self disableVideoFrameObserver];
+    [self.pipController destroyPictureInPicture];
+    [self setPipController:nil];
+    [[VeLivePlayerMultiObserver sharedInstance] removeObserver:kObserverKey];
+    self.player = nil;
+  });
+}
+
+- (BOOL)isPictureInPictureStarted {
+  return VeLivePictureInPictureController.isPictureInPictureStarted;
+}
+
+- (BOOL)isPictureInPictureSupported {
+  return [VeLivePictureInPictureController isPictureInPictureSupported];
+}
+
+- (void)enablePictureInPicture {
+  NSLog(@"PIP: Enable picture-in-picture");
+  self.pipAutoStart = YES;
+  // main thread
+  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];
+      }];
+    }
+  });
+}
+
+- (void)disablePictureInPicture {
+  NSLog(@"PIP: Disable picture-in-picture");
+  self.pipAutoStart = NO;
+  if (!self.pipController) {
+    return;
+  }
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (@available(iOS 14.2, *)) {
+      [self.pipController
+          setCanStartPictureInPictureAutomaticallyFromInline:NO];
+      [self.pipController destroyPictureInPicture];
+      self.pipController = nil;
+    }
+  });
+}
+
+- (void)setListener:(id<VeLivePictureInPictureManagerListener>)listener {
+  _listener = listener;
+}
+
+// MARK: - VeLiveVideoFrameListener
+- (void)onRenderVideoFrame:(TVLManager *_Nonnull)player
+                videoFrame:(VeLivePlayerVideoFrame *_Nonnull)videoFrame {
+  @autoreleasepool {
+    if (@available(iOS 15.0, *)) {
+      if (videoFrame.bufferType == VeLivePlayerVideoBufferTypePixelBuffer) {
+        [self.pipController enqueuePixelBuffer:videoFrame.pixelBuffer];
+      } else if (videoFrame.bufferType ==
+                 VeLivePlayerVideoBufferTypeSampleBuffer) {
+        [self.pipController enqueueSampleBuffer:videoFrame.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");
+}
+
+- (void)pictureInPictureWillStart:
+    (VeLivePictureInPictureController *)pictureInPicture {
+  NSLog(@"PIP: Picture-in-picture will start...");
+}
+
+- (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];
+  }
+  if (!self.pipAutoStart) {
+    [self.pipController destroyPictureInPicture];
+    self.pipController = nil;
+  }
+}
+
+@end