@volcengine/react-native-live-push 1.1.3-rc.1 → 1.3.0-rc.0

package/ios/VeLiveMixerView.h

@@ -0,0 +1,62 @@
+//
+//  VeLiveMixerView.h
+//  react-native-live-push
+//
+//  Created by ByteDance on 2025/06/09.
+//
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <React/RCTComponent.h>
+#import <CoreVideo/CoreVideo.h>
+#import <CoreMedia/CoreMedia.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Bitmap捕获回调协议 - 对应Android的BitmapCaptureCallback
+@protocol VeLiveBitmapCaptureCallback <NSObject>
+- (void)onBitmapCaptured:(UIImage *)bitmap;
+- (void)onCaptureError:(NSString *)error;
+@end
+
+// MixerView代理协议
+@protocol VeLiveMixerViewDelegate <NSObject>
+- (void)onBitmapCaptured:(UIImage *)image viewId:(NSString *)viewId;
+- (void)onCaptureError:(NSString *)error viewId:(NSString *)viewId;
+@end
+
+@interface VeLiveMixerUIView : UIView
+
+// 视图标识
+@property (nonatomic, strong) NSString *viewId;
+
+// 捕获配置属性
+@property (nonatomic, strong) NSString *captureMode;
+@property (nonatomic, strong) NSNumber *captureFramerate;
+
+// React Native 事件回调
+@property (nonatomic, copy) RCTBubblingEventBlock onBitmapCapture;
+@property (nonatomic, copy) RCTBubblingEventBlock onCaptureError;
+
+// 代理
+@property (nonatomic, weak) id<VeLiveMixerViewDelegate> delegate;
+
+// Bitmap捕获回调 - 用于与MixerManager集成
+@property (nonatomic, weak) id<VeLiveBitmapCaptureCallback> bitmapCaptureCallback;
+
+// 控制方法
+- (void)startCapture;
+- (void)stopCapture;
+- (void)performCaptureWithTrigger:(NSString *)trigger;
+
+// 设置bitmap捕获回调
+- (void)setBitmapCaptureCallback:(id<VeLiveBitmapCaptureCallback>)callback;
+
+// UIView转换方法
+- (UIImage *)snapshotIncludeSubviews;
+- (CVPixelBufferRef)createPixelBuffer;
+- (CMSampleBufferRef)createSampleBuffer;
+
+@end
+
+NS_ASSUME_NONNULL_END 

package/ios/VeLiveMixerView.m

@@ -0,0 +1,547 @@
+//
+//  VeLiveMixerView.m
+//  react-native-live-push
+//
+//  Created by ByteDance on 2024/12/09.
+//
+
+#import "VeLiveMixerView.h"
+#import "VeLiveMixerHelper.h"
+#import <AVFoundation/AVFoundation.h>
+#import <CoreImage/CoreImage.h>
+#import <CoreMedia/CoreMedia.h>
+#import <CoreVideo/CoreVideo.h>
+#import <UIKit/UIKit.h>
+
+@interface VeLiveMixerUIView ()
+
+// Capture configuration - Internal properties
+@property(nonatomic, strong) NSString *internalCaptureMode;
+@property(nonatomic, assign) float internalCaptureFramerate;
+
+// Capture state - Align with Android
+@property(nonatomic, strong) NSTimer *captureTimer;
+@property(nonatomic, assign) BOOL isCapturing;
+@property(nonatomic, assign) BOOL isDestroyed;
+@property(nonatomic, assign) CFTimeInterval lastCaptureTime;
+
+// Performance optimization - Align with Android
+@property(nonatomic) CVPixelBufferRef lastPixelBuffer;
+
+@end
+
+@implementation VeLiveMixerUIView
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  self = [super initWithFrame:frame];
+  if (self) {
+    [self initializeCapture];
+    [self setupUIView];
+  }
+  return self;
+}
+
+- (void)setupUIView {
+  // Reference VeLivePushView.m settings, but keep our mixed view features
+  self.clipsToBounds = YES; // Changed to YES, consistent with VeLivePushView
+  self.userInteractionEnabled = YES;
+
+  // Set default background color to transparent, allowing subviews to display
+  self.backgroundColor = [UIColor clearColor];
+}
+
+- (void)initializeCapture {
+  // Initialize defaults - Completely align with Android
+  _internalCaptureMode = @"onchange";
+  _internalCaptureFramerate = 5.0f; // realTime mode default 5 fps
+
+  _isCapturing = NO;
+  _isDestroyed = NO;
+  _lastCaptureTime = 0;
+  _lastPixelBuffer = NULL;
+}
+
+#pragma mark - Property Getters/Setters - Align with React Native props
+
+- (NSString *)captureMode {
+  return self.internalCaptureMode;
+}
+
+- (void)setCaptureMode:(NSString *)mode {
+  if ([mode isEqualToString:self.internalCaptureMode])
+    return;
+
+  [self stopCapture];
+  _internalCaptureMode = mode;
+  [self startCapture];
+}
+
+- (NSNumber *)captureFramerate {
+  return @(self.internalCaptureFramerate);
+}
+
+- (void)setCaptureFramerate:(NSNumber *)framerate {
+  _internalCaptureFramerate = MAX(1.0f, MIN(60.0f, [framerate floatValue]));
+  if ([self.internalCaptureMode isEqualToString:@"realtime"]) {
+    [self restartRealtimeCapture];
+  }
+}
+
+- (void)setViewId:(NSString *)viewId {
+  if (!viewId) {
+    return;
+  }
+
+  // Set viewId
+  _viewId = [viewId copy];
+
+  // Register to global cache - Align with Android's onAttachedToWindow
+  NSMutableDictionary *cachedViews = [VeLiveMixerHelper cachedMixedViews];
+  if (cachedViews) {
+    [cachedViews setObject:self forKey:viewId];
+
+    // Notify MixerHelper view is ready, check for pending callbacks
+    [VeLiveMixerHelper onViewReady:viewId mixerView:self];
+  }
+}
+
+#pragma mark - Capture Methods - Completely align with Android
+
+- (void)startCapture {
+  if (self.isDestroyed)
+    return;
+
+  if ([self.internalCaptureMode isEqualToString:@"onchange"]) {
+    [self startOnChangeCapture];
+  } else if ([self.internalCaptureMode isEqualToString:@"realtime"]) {
+    [self startRealtimeCapture];
+  }
+  // manual mode doesn't auto-start
+}
+
+- (void)stopCapture {
+  [self.captureTimer invalidate];
+  self.captureTimer = nil;
+  self.isCapturing = NO;
+}
+
+- (void)startOnChangeCapture {
+  // onchange mode triggers every 2 seconds
+  self.captureTimer =
+      [NSTimer scheduledTimerWithTimeInterval:2.0
+                                       target:self
+                                     selector:@selector(onChangeCapture)
+                                     userInfo:nil
+                                      repeats:YES];
+}
+
+- (void)onChangeCapture {
+  if (!self.isDestroyed &&
+      [self.internalCaptureMode isEqualToString:@"onchange"]) {
+    @autoreleasepool {
+      [self performCapture:@"onchange"];
+    }
+  }
+}
+
+- (void)startRealtimeCapture {
+  long interval = (long)(1000.0f / self.internalCaptureFramerate);
+  self.captureTimer =
+      [NSTimer scheduledTimerWithTimeInterval:interval / 1000.0
+                                       target:self
+                                     selector:@selector(realtimeCapture)
+                                     userInfo:nil
+                                      repeats:YES];
+}
+
+- (void)realtimeCapture {
+  if (!self.isDestroyed &&
+      [self.internalCaptureMode isEqualToString:@"realtime"]) {
+    @autoreleasepool {
+      [self performCapture:@"realtime"];
+
+      // Every 5 realtime captures, perform background memory cleanup
+      static int captureCount = 0;
+      captureCount++;
+      if (captureCount % 5 == 0) {
+        dispatch_async(
+            dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
+              [[NSURLCache sharedURLCache] removeAllCachedResponses];
+              [[NSURLCache sharedURLCache] setMemoryCapacity:0];
+              [[NSURLCache sharedURLCache]
+                  setMemoryCapacity:10 * 1024 * 1024]; // 10MB
+            });
+      }
+    }
+  }
+}
+
+- (void)restartRealtimeCapture {
+  if ([self.internalCaptureMode isEqualToString:@"realtime"]) {
+    [self stopCapture];
+    [self startRealtimeCapture];
+  }
+}
+
+#pragma mark - Core Capture Logic - Align with Android's performCapture
+
+- (void)performCapture:(NSString *)trigger {
+  if (self.isCapturing || self.isDestroyed)
+    return;
+
+  // Throttle captures to prevent excessive calls
+  CFTimeInterval currentTime = CACurrentMediaTime();
+  if (currentTime - self.lastCaptureTime < 1.0 / 30.0) { // Max 30fps
+    return;
+  }
+  self.lastCaptureTime = currentTime;
+
+  self.isCapturing = YES;
+
+  @try {
+    CVPixelBufferRef pixelBuffer = [self createPixelBuffer];
+    if (pixelBuffer) {
+      [self processPixelBuffer:pixelBuffer trigger:trigger];
+      CVPixelBufferRelease(pixelBuffer);
+    }
+  } @finally {
+    self.isCapturing = NO;
+  }
+}
+
+- (UIImage *)createBitmap {
+  CGSize viewSize = self.bounds.size;
+
+  // Check for valid bounds
+  if (viewSize.width <= 0 || viewSize.height <= 0) {
+    return nil;
+  }
+
+  // Limit maximum image dimensions to prevent memory issues
+  CGFloat maxDimension = 1920.0; // Max 1920px on either side
+  CGFloat scale = [UIScreen mainScreen].scale;
+
+  // Calculate actual pixel dimensions
+  CGFloat pixelWidth = viewSize.width * scale;
+  CGFloat pixelHeight = viewSize.height * scale;
+
+  // Scale down if too large
+  if (pixelWidth > maxDimension || pixelHeight > maxDimension) {
+    CGFloat scaleDown =
+        MIN(maxDimension / pixelWidth, maxDimension / pixelHeight);
+    scale = scale * scaleDown;
+  }
+
+  // Further limit scale on very large views
+  if (viewSize.width * viewSize.height > 1000000) { // > 1M points
+    scale = MIN(scale, 1.0);
+  }
+
+  @autoreleasepool {
+    UIGraphicsBeginImageContextWithOptions(viewSize, NO, scale);
+
+    CGContextRef context = UIGraphicsGetCurrentContext();
+    if (!context) {
+      UIGraphicsEndImageContext();
+      return nil;
+    }
+
+    [self drawViewHierarchyInRect:self.bounds afterScreenUpdates:NO];
+    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
+    UIGraphicsEndImageContext();
+
+    return image;
+  }
+}
+
+#pragma mark - Public Methods - Align with Android interface
+
+// Align with Android's performManualCapture
+- (void)performCaptureWithTrigger:(NSString *)trigger {
+  [self performCapture:trigger];
+}
+
+// Align with Android's setBitmapCaptureCallback
+- (void)setBitmapCaptureCallback:(id<VeLiveBitmapCaptureCallback>)callback {
+  _bitmapCaptureCallback = callback;
+}
+
+#pragma mark - Cleanup - Align with Android
+
+- (void)cleanup {
+  self.isDestroyed = YES;
+  [self stopCapture];
+
+  // Clean up pixelBuffer cache
+  if (self.lastPixelBuffer) {
+    CVPixelBufferRelease(self.lastPixelBuffer);
+    self.lastPixelBuffer = NULL;
+  }
+
+  // Clean up callback references, avoid circular references
+  self.bitmapCaptureCallback = nil;
+}
+
+- (void)dealloc {
+  // Remove from global cache
+  if (self.viewId) {
+    NSMutableDictionary *cachedViews = [VeLiveMixerHelper cachedMixedViews];
+    if (cachedViews) {
+      [cachedViews removeObjectForKey:self.viewId];
+    }
+  }
+}
+
+#pragma mark - View Conversion Methods
+
+- (UIImage *)snapshotIncludeSubviews {
+  CGSize viewSize = self.bounds.size;
+
+  // Check for valid bounds
+  if (viewSize.width <= 0 || viewSize.height <= 0) {
+    return nil;
+  }
+
+  // Limit maximum image dimensions to prevent memory issues
+  CGFloat maxDimension = 1920.0; // Max 1920px on either side
+  CGFloat scale = [UIScreen mainScreen].scale;
+
+  // Calculate actual pixel dimensions
+  CGFloat pixelWidth = viewSize.width * scale;
+  CGFloat pixelHeight = viewSize.height * scale;
+
+  // Scale down if too large
+  if (pixelWidth > maxDimension || pixelHeight > maxDimension) {
+    CGFloat scaleDown =
+        MIN(maxDimension / pixelWidth, maxDimension / pixelHeight);
+    scale = scale * scaleDown;
+  }
+
+  // Further limit scale on very large views
+  if (viewSize.width * viewSize.height > 1000000) { // > 1M points
+    scale = MIN(scale, 1.0);
+  }
+
+  @autoreleasepool {
+    UIGraphicsBeginImageContextWithOptions(viewSize, NO, scale);
+
+    CGContextRef context = UIGraphicsGetCurrentContext();
+    if (!context) {
+      UIGraphicsEndImageContext();
+      return nil;
+    }
+
+    [self drawViewHierarchyInRect:self.bounds afterScreenUpdates:NO];
+    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
+    UIGraphicsEndImageContext();
+
+    return image;
+  }
+}
+
+- (CVPixelBufferRef)createPixelBuffer {
+  UIImage *bitmap = [self createBitmap];
+  if (!bitmap) {
+    return NULL;
+  }
+
+  return [self pixelBufferFromUIImage:bitmap];
+}
+
+- (CMSampleBufferRef)createSampleBuffer {
+  // Implement sample buffer creation (corresponds to Android's VideoFrame)
+  return NULL; // Temporary return NULL, implementation based on needs
+}
+
+#pragma mark - React Native Child View Support - Focus on RN subview management
+
+// React Native subview insertion - This is the main method called by RN
+// framework
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)atIndex {
+  // Process directly on main thread because React Native ensures thread safety
+  [super insertSubview:subview atIndex:atIndex];
+  [self setSubViewAutoLayout:subview];
+}
+
+- (void)removeReactSubview:(UIView *)subview {
+  [subview removeFromSuperview];
+}
+
+- (NSArray<UIView *> *)reactSubviews {
+  return [self subviews];
+}
+
+// Set Auto Layout constraints - Ensure subview fills parent view
+- (void)setSubViewAutoLayout:(UIView *)subview {
+  // Disable automatic conversion, use constraints layout
+  subview.translatesAutoresizingMaskIntoConstraints = NO;
+
+  // Set four-side constraints, let subview fill parent view
+  [NSLayoutConstraint activateConstraints:@[
+    [subview.leadingAnchor constraintEqualToAnchor:self.leadingAnchor],
+    [subview.trailingAnchor constraintEqualToAnchor:self.trailingAnchor],
+    [subview.topAnchor constraintEqualToAnchor:self.topAnchor],
+    [subview.bottomAnchor constraintEqualToAnchor:self.bottomAnchor]
+  ]];
+}
+
+// Override layoutSubviews to ensure correct subview layout
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  if (self.isDestroyed)
+    return;
+
+  // Original capture logic
+  if ([self.internalCaptureMode isEqualToString:@"onchange"]) {
+    [self performCapture:@"onchange"];
+  }
+}
+
+// Ensure UIView can correctly display background color and subviews
+- (void)setBackgroundColor:(UIColor *)backgroundColor {
+  [super setBackgroundColor:backgroundColor];
+}
+
+#pragma mark - Helper Methods
+
+- (CVPixelBufferRef)pixelBufferFromUIImage:(UIImage *)image {
+  if (!image) {
+    return NULL;
+  }
+
+  CGImageRef cgImage = image.CGImage;
+  if (!cgImage) {
+    return NULL;
+  }
+
+  CGFloat width = CGImageGetWidth(cgImage);
+  CGFloat height = CGImageGetHeight(cgImage);
+
+  NSDictionary *options = @{
+    (NSString *)kCVPixelBufferCGImageCompatibilityKey : @YES,
+    (NSString *)kCVPixelBufferCGBitmapContextCompatibilityKey : @YES,
+    (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{}
+  };
+
+  CVPixelBufferRef pixelBuffer = NULL;
+  CVReturn status = CVPixelBufferCreate(
+      kCFAllocatorDefault, width, height, kCVPixelFormatType_32BGRA,
+      (__bridge CFDictionaryRef)options, &pixelBuffer);
+
+  if (status != kCVReturnSuccess || !pixelBuffer) {
+    return NULL;
+  }
+
+  CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+
+  void *pixelData = CVPixelBufferGetBaseAddress(pixelBuffer);
+  size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
+
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(
+      pixelData, width, height, 8, bytesPerRow, colorSpace,
+      kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host);
+
+  if (!context) {
+    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+    CVPixelBufferRelease(pixelBuffer);
+    CGColorSpaceRelease(colorSpace);
+    return NULL;
+  }
+
+  CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
+
+  CGContextRelease(context);
+  CGColorSpaceRelease(colorSpace);
+  CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+
+  return pixelBuffer;
+}
+
+- (void)processPixelBuffer:(CVPixelBufferRef)pixelBuffer
+                   trigger:(NSString *)trigger {
+  @autoreleasepool {
+    if (!pixelBuffer) {
+      return;
+    }
+
+    // Clean up old pixelBuffer cache
+    if (self.lastPixelBuffer) {
+      CVPixelBufferRelease(self.lastPixelBuffer);
+      self.lastPixelBuffer = NULL;
+    }
+
+    // Cache pixelBuffer for non-realtime modes
+    if (![trigger isEqualToString:@"realtime"]) {
+      // Retain current pixelBuffer as cache
+      CVPixelBufferRetain(pixelBuffer);
+      self.lastPixelBuffer = pixelBuffer;
+    }
+
+    // If callback is needed, create temporary UIImage
+    if (self.bitmapCaptureCallback || self.onBitmapCapture) {
+      UIImage *bitmap = [self UIImageFromPixelBuffer:pixelBuffer];
+      if (bitmap) {
+        if (self.bitmapCaptureCallback) {
+          @try {
+            [self.bitmapCaptureCallback onBitmapCaptured:bitmap];
+          } @catch (NSException *exception) {
+            if (self.bitmapCaptureCallback) {
+              [self.bitmapCaptureCallback
+                  onCaptureError:[NSString
+                                     stringWithFormat:@"Callback error: %@",
+                                                      exception.reason]];
+            }
+          }
+        }
+
+        if (self.onBitmapCapture) {
+          @autoreleasepool {
+            NSDictionary *event = @{
+              @"trigger" : trigger ?: @"unknown",
+              @"success" : @(YES),
+              @"bitmapWidth" : @(bitmap.size.width),
+              @"bitmapHeight" : @(bitmap.size.height)
+            };
+            self.onBitmapCapture(event);
+          }
+        }
+      }
+    }
+
+    // Memory cleanup for realtime mode
+    if ([trigger isEqualToString:@"realtime"]) {
+      static int realtimeCount = 0;
+      realtimeCount++;
+      if (realtimeCount % 10 == 0) {
+        dispatch_async(
+            dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
+              @autoreleasepool {
+                [[NSURLCache sharedURLCache] removeAllCachedResponses];
+              }
+            });
+      }
+    }
+  }
+}
+
+- (UIImage *)UIImageFromPixelBuffer:(CVPixelBufferRef)pixelBuffer {
+  if (!pixelBuffer) {
+    return nil;
+  }
+
+  CIImage *ciImage = [CIImage imageWithCVPixelBuffer:pixelBuffer];
+  CIContext *context = [CIContext contextWithOptions:nil];
+  CGImageRef cgImage = [context createCGImage:ciImage fromRect:ciImage.extent];
+
+  if (!cgImage) {
+    return nil;
+  }
+
+  UIImage *image = [UIImage imageWithCGImage:cgImage];
+  CGImageRelease(cgImage);
+
+  return image;
+}
+
+@end

package/ios/VeLiveMixerViewManager.m

@@ -0,0 +1,56 @@
+//
+//  VeLiveMixerViewManager.m
+//  react-native-live-push
+//
+//  Created to manage VeLiveMixerView React Native component
+//
+
+#import "VeLiveMixerView.h"
+#import <Foundation/Foundation.h>
+#import <React/RCTComponent.h>
+#import <React/RCTViewManager.h>
+#import <UIKit/UIKit.h>
+
+@interface VeLiveMixerViewManager : RCTViewManager
+@end
+
+@implementation VeLiveMixerViewManager
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+RCT_EXPORT_MODULE(VeLiveMixView)
+
+- (VeLiveMixerUIView *)view {
+  VeLiveMixerUIView *view = [[VeLiveMixerUIView alloc] init];
+  view.accessibilityLabel = @"VeLiveMixerUIView";
+  return view;
+}
+
+// 导出视图ID属性 - 使用自定义属性处理
+RCT_CUSTOM_VIEW_PROPERTY(viewId, NSString, VeLiveMixerUIView) {
+  if (json == nil) {
+    return;
+  }
+
+  NSString *viewId = [RCTConvert NSString:json];
+  [view setViewId:viewId];
+}
+
+// 导出捕获配置属性
+RCT_CUSTOM_VIEW_PROPERTY(captureMode, NSString, VeLiveMixerUIView) {
+  NSString *captureMode = [RCTConvert NSString:json];
+  if (captureMode != nil) {
+    [view setCaptureMode:captureMode];
+  } else {
+    [view setCaptureMode:@"onchange"];
+  }
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(captureFramerate, NSNumber, VeLiveMixerUIView) {
+  NSNumber *framerate = [RCTConvert NSNumber:json];
+  [view setCaptureFramerate:framerate];
+}
+
+@end