@byteplus/react-native-live-push 1.1.3-rc.0 → 1.1.3-rc.2

package/ios/VeLiveMixerView.m

@@ -0,0 +1,592 @@
+//
+//  VeLiveMixerView.m
+//  react-native-live-push
+//
+//  Created by ByteDance on 2024/12/09.
+//
+
+#import "VeLiveMixerView.h"
+#import "VeLiveMixerHelper.h"
+#import <UIKit/UIKit.h>
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMedia/CoreMedia.h>
+#import <CoreVideo/CoreVideo.h>
+
+@interface VeLiveMixerUIView ()
+
+// Mix configuration - Align with Android
+@property(nonatomic, assign) float mixX;
+@property(nonatomic, assign) float mixY;
+@property(nonatomic, assign) float mixWidth;
+@property(nonatomic, assign) float mixHeight;
+@property(nonatomic, assign) int mixZOrder;
+@property(nonatomic, assign) int mixRenderMode;
+
+// Capture configuration - Internal properties
+@property(nonatomic, strong) NSString *internalCaptureMode;
+@property(nonatomic, assign) float internalCaptureFramerate;
+@property(nonatomic, assign) float internalAutoSensitivity;
+
+// 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, strong) UIImage *lastBitmap;
+
+// Auto mode state - Align with Android
+@property(nonatomic, assign) int changeCount;
+@property(nonatomic, assign) CFTimeInterval windowStartTime;
+@property(nonatomic, assign) BOOL isInRealtimeMode;
+
+@end
+
+@implementation VeLiveMixerUIView
+
+static const CFTimeInterval AUTO_WINDOW_SECONDS = 2.0; // 2 second window
+static const int HIGH_CHANGE_THRESHOLD = 10;
+static const int LOW_CHANGE_THRESHOLD = 2;
+
+- (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];
+  
+  NSLog(@"[VeLiveMixerView] 🎨 setupUIView completed (clipsToBounds=YES, like VeLivePushView)");
+}
+
+- (void)initializeCapture {
+  // Initialize defaults - Completely align with Android
+  _mixX = 0.0f;
+  _mixY = 0.0f;
+  _mixWidth = 0.0f;
+  _mixHeight = 0.0f;
+  _mixZOrder = 0;
+  _mixRenderMode = 0;
+  
+  _internalCaptureMode = @"onchange";
+  _internalCaptureFramerate = 30.0f;
+  _internalAutoSensitivity = 5.0f;
+  
+  _isCapturing = NO;
+  _isDestroyed = NO;
+  _lastCaptureTime = 0;
+  
+  // Auto mode state
+  _changeCount = 0;
+  _windowStartTime = 0;
+  _isInRealtimeMode = NO;
+}
+
+#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];
+  }
+}
+
+- (NSNumber *)autoSensitivity {
+  return @(self.internalAutoSensitivity);
+}
+
+- (void)setAutoSensitivity:(NSNumber *)sensitivity {
+  _internalAutoSensitivity = MAX(1.0f, MIN(10.0f, [sensitivity floatValue]));
+}
+
+- (void)setViewId:(NSString *)viewId {
+  if (!viewId) {
+    return;
+  }
+  
+  NSLog(@"[VeLiveMixerView] 📝 setViewId: %@", viewId);
+  
+  // 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];
+    NSLog(@"[VeLiveMixerView] ✅ Registered to cachedMixedViews: %@", viewId);
+    
+    // Notify MixerHelper view is ready, check for pending callbacks
+    [VeLiveMixerHelper onViewReady:viewId mixerView:self];
+  }
+}
+
+#pragma mark - Property setters for React Native props - Align with Android
+
+// React Native property setter - Corresponds to VeLiveMixerViewManager.m properties
+- (void)setX:(NSNumber *)x {
+  _x = x;
+  _mixX = [x floatValue];
+}
+
+- (void)setY:(NSNumber *)y {
+  _y = y;
+  _mixY = [y floatValue];
+}
+
+- (void)setWidth:(NSNumber *)width {
+  _width = width;
+  _mixWidth = [width floatValue];
+}
+
+- (void)setHeight:(NSNumber *)height {
+  _height = height;
+  _mixHeight = [height floatValue];
+}
+
+- (void)setZOrder:(NSNumber *)zOrder {
+  _zOrder = zOrder;
+  _mixZOrder = [zOrder intValue];
+}
+
+- (void)setRenderMode:(NSNumber *)renderMode {
+  _renderMode = renderMode;
+  _mixRenderMode = [renderMode intValue];
+}
+
+#pragma mark - Internal setters for mix configuration - Internal use
+
+- (void)setMixX:(float)x { _mixX = x; }
+- (void)setMixY:(float)y { _mixY = y; }
+- (void)setMixWidth:(float)width { _mixWidth = width; }
+- (void)setMixHeight:(float)height { _mixHeight = height; }
+- (void)setMixZOrder:(int)zOrder { _mixZOrder = zOrder; }
+- (void)setMixRenderMode:(int)renderMode { _mixRenderMode = renderMode; }
+
+#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];
+  } else if ([self.internalCaptureMode isEqualToString:@"auto"]) {
+    [self startAutoCapture];
+  }
+  // manual mode doesn't auto-start
+}
+
+- (void)stopCapture {
+  [self.captureTimer invalidate];
+  self.captureTimer = nil;
+  self.isCapturing = NO;
+}
+
+- (void)startOnChangeCapture {
+  // onchange mode triggers in layoutSubviews
+}
+
+- (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), ^{
+          NSLog(@"[VeLiveMixerView] 🧹 Performing background memory cleanup after %d captures", captureCount);
+          [[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];
+  }
+}
+
+- (void)startAutoCapture {
+  // Start with onchange mode
+  self.isInRealtimeMode = NO;
+  self.windowStartTime = CACurrentMediaTime();
+  self.changeCount = 0;
+  [self startOnChangeCapture];
+}
+
+#pragma mark - Layout Change Detection - Align with Android's onViewChanged
+
+- (void)handleAutoModeChange {
+  if (!self.isInRealtimeMode) {
+    [self performCapture:@"auto_onchange"];
+  }
+  
+  // Count changes for auto mode
+  self.changeCount++;
+  
+  CFTimeInterval currentTime = CACurrentMediaTime();
+  if (currentTime - self.windowStartTime >= AUTO_WINDOW_SECONDS) {
+    [self evaluateAutoMode];
+    // Reset window
+    self.windowStartTime = currentTime;
+    self.changeCount = 0;
+  }
+}
+
+- (void)evaluateAutoMode {
+  float changesPerSecond = self.changeCount / AUTO_WINDOW_SECONDS;
+  float threshold = self.internalAutoSensitivity;
+  
+  BOOL shouldBeRealtime = changesPerSecond > (HIGH_CHANGE_THRESHOLD / threshold);
+  BOOL shouldBeOnChange = changesPerSecond < (LOW_CHANGE_THRESHOLD / threshold);
+  
+  if (shouldBeRealtime && !self.isInRealtimeMode) {
+    [self switchToRealtimeMode];
+  } else if (shouldBeOnChange && self.isInRealtimeMode) {
+    [self switchToOnChangeMode];
+  }
+}
+
+- (void)switchToRealtimeMode {
+  self.isInRealtimeMode = YES;
+  [self startRealtimeCapture];
+}
+
+- (void)switchToOnChangeMode {
+  self.isInRealtimeMode = NO;
+  [self.captureTimer invalidate];
+  self.captureTimer = nil;
+}
+
+#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/60.0) { // Max 60fps
+    return;
+  }
+  self.lastCaptureTime = currentTime;
+  
+  self.isCapturing = YES;
+  
+  @try {
+    UIImage *bitmap = [self createBitmap];
+    if (bitmap) {
+      [self processBitmap:bitmap trigger:trigger];
+    }
+  } @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;
+  }
+}
+
+- (void)processBitmap:(UIImage *)bitmap trigger:(NSString *)trigger {
+  @autoreleasepool {
+    if (!bitmap || bitmap.size.width <= 0 || bitmap.size.height <= 0) {
+      return;
+    }
+    
+    // Check bitmap memory size and skip if too large
+    CGFloat bitmapMemoryMB = (bitmap.size.width * bitmap.size.height * 4.0) / (1024.0 * 1024.0);
+    if (bitmapMemoryMB > 50.0) { // Skip bitmaps larger than 50MB
+      return;
+    }
+    
+    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),
+          @"x": @(self.mixX),
+          @"y": @(self.mixY),
+          @"width": @(self.mixWidth),
+          @"height": @(self.mixHeight),
+          @"zOrder": @(self.mixZOrder),
+          @"renderMode": @(self.mixRenderMode),
+          @"bitmapWidth": @(bitmap.size.width),
+          @"bitmapHeight": @(bitmap.size.height)
+        };
+        self.onBitmapCapture(event);
+      }
+    }
+    
+    // Clean up old bitmap immediately
+    if (self.lastBitmap) {
+      self.lastBitmap = nil;
+    }
+    
+    // For realtime mode, don't keep bitmap reference to reduce memory usage
+    if ([trigger isEqualToString:@"realtime"]) {
+      // Bitmap will be auto-released at autoreleasepool end
+      
+      // Force memory cleanup every 10 realtime captures
+      static int realtimeCount = 0;
+      realtimeCount++;
+      if (realtimeCount % 10 == 0) {
+        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
+          @autoreleasepool {
+            [[NSURLCache sharedURLCache] removeAllCachedResponses];
+          }
+        });
+      }
+    } else {
+      self.lastBitmap = bitmap;
+    }
+  }
+}
+
+#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 {
+  NSLog(@"[VeLiveMixerView] 🧹 Starting cleanup for viewId: %@", self.viewId);
+  
+  self.isDestroyed = YES;
+  [self stopCapture];
+  
+  // Clean up bitmap cache
+  self.lastBitmap = nil;
+  
+  // Clean up callback references, avoid circular references
+  self.bitmapCaptureCallback = nil;
+  
+  NSLog(@"[VeLiveMixerView] ✅ Cleanup completed for viewId: %@", self.viewId);
+}
+
+- (void)dealloc {
+  // Remove from global cache
+  if (self.viewId) {
+    NSMutableDictionary *cachedViews = [VeLiveMixerHelper cachedMixedViews];
+    if (cachedViews) {
+      [cachedViews removeObjectForKey:self.viewId];
+      NSLog(@"[VeLiveMixerView] ♻️ Removed from cachedMixedViews: %@", self.viewId);
+    }
+  }
+  
+  NSLog(@"[VeLiveMixerView] 🗑️ Deallocated: %@", 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 {
+  // Implement pixel buffer creation (corresponds to Android's ByteBuffer)
+  return NULL; // Temporary return NULL, implementation based on needs
+}
+
+- (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 {
+  NSLog(@"[VeLiveMixerView] 📱 insertReactSubview: %@ at index: %ld", subview.class, (long)atIndex);
+  
+  // Process directly on main thread because React Native ensures thread safety
+  [super insertSubview:subview atIndex:atIndex];
+  [self setSubViewAutoLayout:subview];
+}
+
+- (void)removeReactSubview:(UIView *)subview {
+  NSLog(@"[VeLiveMixerView] 🗑️ removeReactSubview: %@", subview.class);
+  [subview removeFromSuperview];
+}
+
+- (NSArray<UIView *> *)reactSubviews {
+  return [self subviews];
+}
+
+// Set Auto Layout constraints - Ensure subview fills parent view
+- (void)setSubViewAutoLayout:(UIView *)subview {
+  NSLog(@"[VeLiveMixerView] 📐 setSubViewAutoLayout for: %@", subview.class);
+  
+  // 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]
+  ]];
+  
+  NSLog(@"[VeLiveMixerView] ✅ Auto Layout constraints applied for subview");
+}
+
+// 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"];
+  } else if ([self.internalCaptureMode isEqualToString:@"auto"]) {
+    [self handleAutoModeChange];
+  }
+}
+
+// Ensure UIView can correctly display background color and subviews
+- (void)setBackgroundColor:(UIColor *)backgroundColor {
+  NSLog(@"[VeLiveMixerView] 🎨 setBackgroundColor: %@", backgroundColor);
+  [super setBackgroundColor:backgroundColor];
+}
+
+@end

package/ios/VeLiveMixerViewManager.m

@@ -0,0 +1,92 @@
+//
+//  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];
+}
+
+// 导出混合配置属性 - 与Android保持一致的属性名
+RCT_CUSTOM_VIEW_PROPERTY(x, NSNumber, VeLiveMixerUIView) {
+  NSNumber *x = [RCTConvert NSNumber:json];
+  [view setX:x];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(y, NSNumber, VeLiveMixerUIView) {
+  NSNumber *y = [RCTConvert NSNumber:json];
+  [view setY:y];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(width, NSNumber, VeLiveMixerUIView) {
+  NSNumber *width = [RCTConvert NSNumber:json];
+  [view setWidth:width];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(height, NSNumber, VeLiveMixerUIView) {
+  NSNumber *height = [RCTConvert NSNumber:json];
+  [view setHeight:height];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(zOrder, NSNumber, VeLiveMixerUIView) {
+  NSNumber *zOrder = [RCTConvert NSNumber:json];
+  [view setZOrder:zOrder];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(renderMode, NSNumber, VeLiveMixerUIView) {
+  NSNumber *renderMode = [RCTConvert NSNumber:json];
+  [view setRenderMode:renderMode];
+}
+
+// 导出捕获配置属性
+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];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(autoSensitivity, NSNumber, VeLiveMixerUIView) {
+  NSNumber *sensitivity = [RCTConvert NSNumber:json];
+  [view setAutoSensitivity:sensitivity];
+}
+
+@end