tirtc-react-native 2.2.0

package/ios/TiRtcReactNativeOptions.mm

@@ -0,0 +1,123 @@
+#import "TiRtcReactNativeOptions.h"
+
+static TiRtcAudioAecMode TiRtcReactNativeAudioAecMode(NSString* value) {
+  return [value isEqualToString:@"enabled"] ? TiRtcAudioAecModeEnabled : TiRtcAudioAecModeDisabled;
+}
+
+static TiRtcAudioAgcLevel TiRtcReactNativeAudioAgcLevel(NSString* value) {
+  if ([value isEqualToString:@"low"]) {
+    return TiRtcAudioAgcLevelLow;
+  }
+  if ([value isEqualToString:@"medium"]) {
+    return TiRtcAudioAgcLevelMedium;
+  }
+  if ([value isEqualToString:@"high"]) {
+    return TiRtcAudioAgcLevelHigh;
+  }
+  return TiRtcAudioAgcLevelDisabled;
+}
+
+static TiRtcAudioAnsLevel TiRtcReactNativeAudioAnsLevel(NSString* value) {
+  if ([value isEqualToString:@"low"]) {
+    return TiRtcAudioAnsLevelLow;
+  }
+  if ([value isEqualToString:@"medium"]) {
+    return TiRtcAudioAnsLevelMedium;
+  }
+  if ([value isEqualToString:@"high"]) {
+    return TiRtcAudioAnsLevelHigh;
+  }
+  return TiRtcAudioAnsLevelDisabled;
+}
+
+static TiRtcVideoDecoderPreference TiRtcReactNativeVideoDecoderPreference(NSString* value) {
+  if ([value isEqualToString:@"software"]) {
+    return TiRtcVideoDecoderPreferenceSoftware;
+  }
+  if ([value isEqualToString:@"hardware"]) {
+    return TiRtcVideoDecoderPreferenceHardware;
+  }
+  return TiRtcVideoDecoderPreferenceAuto;
+}
+
+static TiRtcOutputBufferStrategy TiRtcReactNativeBufferStrategy(NSString* value) {
+  return [value isEqualToString:@"noBuffer"] ? TiRtcOutputBufferStrategyNoBuffer
+                                             : TiRtcOutputBufferStrategyAutomatic;
+}
+
+static NSNumber* TiRtcReactNativeOptionalDouble(std::optional<double> value) {
+  return value.has_value() ? @(value.value()) : nil;
+}
+
+TiRtcAudioOutputOptions* TiRtcReactNativeAudioOutputOptions(
+    JS::NativeTiRtc::NativeAudioOutputOptions& options) {
+  TiRtcAudioOutputOptions* nativeOptions = [TiRtcAudioOutputOptions new];
+  nativeOptions.agcLevel = TiRtcReactNativeAudioAgcLevel(options.agcLevel());
+  nativeOptions.ansLevel = TiRtcReactNativeAudioAnsLevel(options.ansLevel());
+  nativeOptions.bufferStrategy = TiRtcReactNativeBufferStrategy(options.bufferStrategy());
+  nativeOptions.maxBufferWatermarkMs =
+      TiRtcReactNativeOptionalDouble(options.maxBufferWatermarkMs());
+  return nativeOptions;
+}
+
+TiRtcVideoOutputOptions* TiRtcReactNativeVideoOutputOptions(
+    JS::NativeTiRtc::NativeVideoOutputOptions& options) {
+  TiRtcVideoOutputOptions* nativeOptions = [TiRtcVideoOutputOptions new];
+  nativeOptions.decoderPreference =
+      TiRtcReactNativeVideoDecoderPreference(options.decoderPreference());
+  nativeOptions.bufferStrategy = TiRtcReactNativeBufferStrategy(options.bufferStrategy());
+  nativeOptions.maxBufferWatermarkMs =
+      TiRtcReactNativeOptionalDouble(options.maxBufferWatermarkMs());
+  return nativeOptions;
+}
+
+TiRtcAudioInputOptions* TiRtcReactNativeAudioInputOptions(
+    JS::NativeTiRtc::NativeAudioInputOptions& options) {
+  TiRtcAudioInputOptions* nativeOptions = [TiRtcAudioInputOptions new];
+  NSString* codec = options.codec();
+  if ([codec isEqualToString:@"aac"]) {
+    nativeOptions.codec = TiRtcAudioCodecAac;
+  } else if ([codec isEqualToString:@"pcm"]) {
+    nativeOptions.codec = TiRtcAudioCodecPcm;
+  } else if ([codec isEqualToString:@"opus"]) {
+    nativeOptions.codec = TiRtcAudioCodecOpus;
+  } else if ([codec isEqualToString:@"amr"]) {
+    nativeOptions.codec = TiRtcAudioCodecAmr;
+  } else {
+    nativeOptions.codec = TiRtcAudioCodecG711a;
+  }
+  nativeOptions.sampleRate = [options.sampleRate() isEqualToString:@"rate8k"]
+                                 ? TiRtcAudioSampleRateRate8k
+                                 : TiRtcAudioSampleRateRate16k;
+  nativeOptions.channels = TiRtcAudioChannelCountMono;
+  nativeOptions.aecMode = TiRtcReactNativeAudioAecMode(options.aecMode());
+  nativeOptions.agcLevel = TiRtcReactNativeAudioAgcLevel(options.agcLevel());
+  nativeOptions.ansLevel = TiRtcReactNativeAudioAnsLevel(options.ansLevel());
+  return nativeOptions;
+}
+
+TiRtcVideoInputOptions* TiRtcReactNativeVideoInputOptions(
+    JS::NativeTiRtc::NativeVideoInputOptions& options) {
+  TiRtcVideoInputOptions* nativeOptions = [TiRtcVideoInputOptions new];
+  NSString* codec = options.codec();
+  if ([codec isEqualToString:@"mjpeg"]) {
+    nativeOptions.codec = TiRtcVideoEncoderCodecMjpeg;
+  } else {
+    nativeOptions.codec = TiRtcVideoEncoderCodecH264;
+  }
+  nativeOptions.width = (uint32_t)MAX(0, options.width());
+  nativeOptions.height = (uint32_t)MAX(0, options.height());
+  NSString* frameRate = options.frameRate();
+  if ([frameRate isEqualToString:@"fps10"]) {
+    nativeOptions.frameRate = TiRtcVideoFrameRateFps10;
+  } else if ([frameRate isEqualToString:@"fps30"]) {
+    nativeOptions.frameRate = TiRtcVideoFrameRateFps30;
+  } else {
+    nativeOptions.frameRate = TiRtcVideoFrameRateFps15;
+  }
+  nativeOptions.bitrateKbps = (uint32_t)MAX(0, options.bitrateKbps());
+  nativeOptions.cameraFacing = [options.cameraFacing() isEqualToString:@"back"]
+                                   ? TiRtcCameraFacingBack
+                                   : TiRtcCameraFacingFront;
+  return nativeOptions;
+}

package/ios/TiRtcReactNativeRegistry.h

@@ -0,0 +1,20 @@
+#import <Foundation/Foundation.h>
+
+@class TiRtcReactNativeEventSink;
+
+@interface TiRtcReactNativeRegistry : NSObject
+
++ (instancetype)sharedRegistry;
+
+- (NSInteger)addObject:(id)object;
+- (NSInteger)addObject:(id)object generation:(NSInteger*)generation;
+- (void)setEventSink:(TiRtcReactNativeEventSink*)eventSink;
+- (void)setDelegate:(id)delegate forObjectId:(NSInteger)objectId;
+- (id)objectForId:(NSInteger)objectId;
+- (NSInteger)generationForObjectId:(NSInteger)objectId;
+- (void)reportVideoOutputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message;
+- (void)reportVideoInputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message;
+- (void)releaseObject:(NSInteger)objectId;
+- (BOOL)hasLiveObjects;
+
+@end

package/ios/TiRtcReactNativeRegistry.mm

@@ -0,0 +1,119 @@
+#import "TiRtcReactNativeRegistry.h"
+
+#import "TiRtcReactNativeEventSink.h"
+
+@interface TiRtcReactNativeRegistryEntry : NSObject
+@property(nonatomic, strong) id object;
+@property(nonatomic, strong) id delegate;
+@property(nonatomic, assign) NSInteger generation;
+@end
+
+@implementation TiRtcReactNativeRegistryEntry
+@end
+
+@implementation TiRtcReactNativeRegistry {
+  NSLock* _lock;
+  NSMutableDictionary<NSNumber*, TiRtcReactNativeRegistryEntry*>* _entries;
+  __weak TiRtcReactNativeEventSink* _eventSink;
+  NSInteger _nextId;
+  NSInteger _nextGeneration;
+}
+
++ (instancetype)sharedRegistry {
+  static TiRtcReactNativeRegistry* registry;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    registry = [TiRtcReactNativeRegistry new];
+  });
+  return registry;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _lock = [NSLock new];
+    _entries = [NSMutableDictionary new];
+    _nextId = 1;
+    _nextGeneration = 1;
+  }
+  return self;
+}
+
+- (NSInteger)addObject:(id)object {
+  return [self addObject:object generation:nil];
+}
+
+- (NSInteger)addObject:(id)object generation:(NSInteger*)generation {
+  [_lock lock];
+  NSInteger objectId = _nextId++;
+  NSInteger objectGeneration = _nextGeneration++;
+  TiRtcReactNativeRegistryEntry* entry = [TiRtcReactNativeRegistryEntry new];
+  entry.object = object;
+  entry.generation = objectGeneration;
+  _entries[@(objectId)] = entry;
+  if (generation != nil) {
+    *generation = objectGeneration;
+  }
+  [_lock unlock];
+  return objectId;
+}
+
+- (void)setEventSink:(TiRtcReactNativeEventSink*)eventSink {
+  [_lock lock];
+  _eventSink = eventSink;
+  [_lock unlock];
+}
+
+- (void)setDelegate:(id)delegate forObjectId:(NSInteger)objectId {
+  [_lock lock];
+  _entries[@(objectId)].delegate = delegate;
+  [_lock unlock];
+}
+
+- (id)objectForId:(NSInteger)objectId {
+  [_lock lock];
+  id object = _entries[@(objectId)].object;
+  [_lock unlock];
+  return object;
+}
+
+- (NSInteger)generationForObjectId:(NSInteger)objectId {
+  [_lock lock];
+  NSInteger generation = _entries[@(objectId)].generation;
+  [_lock unlock];
+  return generation;
+}
+
+- (void)reportVideoOutputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message {
+  [_lock lock];
+  TiRtcReactNativeEventSink* eventSink = _eventSink;
+  BOOL hasObject = _entries[@(objectId)] != nil;
+  [_lock unlock];
+  if (eventSink != nil && hasObject) {
+    [eventSink videoOutputError:objectId code:code message:message];
+  }
+}
+
+- (void)reportVideoInputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message {
+  [_lock lock];
+  TiRtcReactNativeEventSink* eventSink = _eventSink;
+  BOOL hasObject = _entries[@(objectId)] != nil;
+  [_lock unlock];
+  if (eventSink != nil && hasObject) {
+    [eventSink videoInputError:objectId code:code message:message];
+  }
+}
+
+- (void)releaseObject:(NSInteger)objectId {
+  [_lock lock];
+  [_entries removeObjectForKey:@(objectId)];
+  [_lock unlock];
+}
+
+- (BOOL)hasLiveObjects {
+  [_lock lock];
+  BOOL hasObjects = _entries.count > 0;
+  [_lock unlock];
+  return hasObjects;
+}
+
+@end

package/ios/TiRtcVideoInputPreview.h

@@ -0,0 +1,5 @@
+#import <React/RCTViewComponentView.h>
+#import <react/renderer/components/TiRtcSpec/RCTComponentViewHelpers.h>
+
+@interface TiRtcVideoInputPreview : RCTViewComponentView <RCTTiRtcVideoInputPreviewViewProtocol>
+@end

package/ios/TiRtcVideoInputPreview.mm

@@ -0,0 +1,149 @@
+#import "TiRtcVideoInputPreview.h"
+
+#import <AVFoundation/AVFoundation.h>
+#import <QuartzCore/QuartzCore.h>
+#import <react/renderer/components/TiRtcSpec/ComponentDescriptors.h>
+#import <react/renderer/components/TiRtcSpec/Props.h>
+#import <react/renderer/components/TiRtcSpec/ShadowNodes.h>
+
+#import "TiRtcReactNativeNative.h"
+#import "TiRtcReactNativeRegistry.h"
+
+using namespace facebook::react;
+
+static AVLayerVideoGravity TiRtcVideoInputPreviewGravityForResizeMode(
+    TiRtcVideoInputPreviewResizeMode resizeMode) {
+  switch (resizeMode) {
+    case TiRtcVideoInputPreviewResizeMode::Cover:
+      return AVLayerVideoGravityResizeAspectFill;
+    case TiRtcVideoInputPreviewResizeMode::Stretch:
+      return AVLayerVideoGravityResize;
+    case TiRtcVideoInputPreviewResizeMode::Contain:
+    default:
+      return AVLayerVideoGravityResizeAspect;
+  }
+}
+
+@interface TiRtcVideoInputPreview ()
+- (void)applyVideoLayerGeometry;
+- (void)updateAttachedPreview;
+@end
+
+@implementation TiRtcVideoInputPreview {
+  NSInteger _nativeObjectId;
+  NSInteger _generation;
+  NSInteger _attachedObjectId;
+  NSInteger _attachedGeneration;
+  TiRtcVideoInputPreviewResizeMode _resizeMode;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _props = TiRtcVideoInputPreviewShadowNode::defaultSharedProps();
+    _nativeObjectId = 0;
+    _generation = 0;
+    _attachedObjectId = 0;
+    _attachedGeneration = 0;
+    _resizeMode = TiRtcVideoInputPreviewResizeMode::Contain;
+    self.clipsToBounds = YES;
+    self.backgroundColor = UIColor.blackColor;
+  }
+  return self;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<TiRtcVideoInputPreviewComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared&)props oldProps:(const Props::Shared&)oldProps {
+  const auto& oldPropsValue = static_cast<const TiRtcVideoInputPreviewProps&>(*_props);
+  const auto& newPropsValue = static_cast<const TiRtcVideoInputPreviewProps&>(*props);
+  if (oldPropsValue.resizeMode != newPropsValue.resizeMode) {
+    _resizeMode = newPropsValue.resizeMode;
+    [self applyVideoLayerGeometry];
+  }
+  if (oldPropsValue.nativeObjectId != newPropsValue.nativeObjectId ||
+      oldPropsValue.generation != newPropsValue.generation) {
+    _nativeObjectId = newPropsValue.nativeObjectId;
+    _generation = newPropsValue.generation;
+    [self updateAttachedPreview];
+  }
+  [self applyVideoLayerGeometry];
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  [self applyVideoLayerGeometry];
+}
+
+- (void)prepareForRecycle {
+  [self detachNativePreview:_attachedObjectId];
+  _nativeObjectId = 0;
+  _generation = 0;
+  _attachedObjectId = 0;
+  _attachedGeneration = 0;
+  [super prepareForRecycle];
+}
+
+- (void)dealloc {
+  [self detachNativePreview:_attachedObjectId];
+}
+
+- (void)updateAttachedPreview {
+  if (_attachedObjectId > 0 &&
+      (_attachedObjectId != _nativeObjectId || _attachedGeneration != _generation)) {
+    [self detachNativePreview:_attachedObjectId];
+    _attachedObjectId = 0;
+    _attachedGeneration = 0;
+  }
+  if (_nativeObjectId <= 0 || _generation <= 0 ||
+      (_attachedObjectId == _nativeObjectId && _attachedGeneration == _generation)) {
+    return;
+  }
+  TiRtcReactNativeRegistry* registry = [TiRtcReactNativeRegistry sharedRegistry];
+  if ([registry generationForObjectId:_nativeObjectId] != _generation) {
+    return;
+  }
+  id object = [registry objectForId:_nativeObjectId];
+  if ([object isKindOfClass:[TiRtcVideoInput class]]) {
+    int32_t code = [(TiRtcVideoInput*)object attachPreviewTo:self];
+    if (code != 0) {
+      [registry reportVideoInputError:_nativeObjectId code:code message:@"preview attach failed"];
+      return;
+    }
+    _attachedObjectId = _nativeObjectId;
+    _attachedGeneration = _generation;
+    [self applyVideoLayerGeometry];
+  }
+}
+
+- (void)detachNativePreview:(NSInteger)objectId {
+  if (objectId <= 0) {
+    return;
+  }
+  id object = [[TiRtcReactNativeRegistry sharedRegistry] objectForId:objectId];
+  if ([object isKindOfClass:[TiRtcVideoInput class]]) {
+    __unused int32_t code = [(TiRtcVideoInput*)object detachPreview];
+  }
+}
+
+- (void)applyVideoLayerGeometry {
+  AVLayerVideoGravity videoGravity = TiRtcVideoInputPreviewGravityForResizeMode(_resizeMode);
+  [CATransaction begin];
+  [CATransaction setDisableActions:YES];
+  for (CALayer* layer in self.layer.sublayers) {
+    if ([layer isKindOfClass:[AVSampleBufferDisplayLayer class]]) {
+      AVSampleBufferDisplayLayer* displayLayer = (AVSampleBufferDisplayLayer*)layer;
+      displayLayer.frame = self.bounds;
+      displayLayer.videoGravity = videoGravity;
+    }
+  }
+  [CATransaction commit];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> TiRtcVideoInputPreviewCls(void) {
+  return TiRtcVideoInputPreview.class;
+}

package/ios/TiRtcVideoOutputView.h

@@ -0,0 +1,5 @@
+#import <React/RCTViewComponentView.h>
+#import <react/renderer/components/TiRtcSpec/RCTComponentViewHelpers.h>
+
+@interface TiRtcVideoOutputView : RCTViewComponentView <RCTTiRtcVideoOutputViewViewProtocol>
+@end

package/ios/TiRtcVideoOutputView.mm

@@ -0,0 +1,149 @@
+#import "TiRtcVideoOutputView.h"
+
+#import <AVFoundation/AVFoundation.h>
+#import <QuartzCore/QuartzCore.h>
+#import <react/renderer/components/TiRtcSpec/ComponentDescriptors.h>
+#import <react/renderer/components/TiRtcSpec/Props.h>
+#import <react/renderer/components/TiRtcSpec/ShadowNodes.h>
+
+#import "TiRtcReactNativeNative.h"
+#import "TiRtcReactNativeRegistry.h"
+
+using namespace facebook::react;
+
+static AVLayerVideoGravity TiRtcVideoOutputGravityForResizeMode(
+    TiRtcVideoOutputViewResizeMode resizeMode) {
+  switch (resizeMode) {
+    case TiRtcVideoOutputViewResizeMode::Cover:
+      return AVLayerVideoGravityResizeAspectFill;
+    case TiRtcVideoOutputViewResizeMode::Stretch:
+      return AVLayerVideoGravityResize;
+    case TiRtcVideoOutputViewResizeMode::Contain:
+    default:
+      return AVLayerVideoGravityResizeAspect;
+  }
+}
+
+@interface TiRtcVideoOutputView ()
+- (void)applyVideoLayerGeometry;
+- (void)updateAttachedOutput;
+@end
+
+@implementation TiRtcVideoOutputView {
+  NSInteger _nativeObjectId;
+  NSInteger _generation;
+  NSInteger _attachedObjectId;
+  NSInteger _attachedGeneration;
+  TiRtcVideoOutputViewResizeMode _resizeMode;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _props = TiRtcVideoOutputViewShadowNode::defaultSharedProps();
+    _nativeObjectId = 0;
+    _generation = 0;
+    _attachedObjectId = 0;
+    _attachedGeneration = 0;
+    _resizeMode = TiRtcVideoOutputViewResizeMode::Contain;
+    self.clipsToBounds = YES;
+    self.backgroundColor = UIColor.blackColor;
+  }
+  return self;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<TiRtcVideoOutputViewComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared&)props oldProps:(const Props::Shared&)oldProps {
+  const auto& oldPropsValue = static_cast<const TiRtcVideoOutputViewProps&>(*_props);
+  const auto& newPropsValue = static_cast<const TiRtcVideoOutputViewProps&>(*props);
+  if (oldPropsValue.resizeMode != newPropsValue.resizeMode) {
+    _resizeMode = newPropsValue.resizeMode;
+    [self applyVideoLayerGeometry];
+  }
+  if (oldPropsValue.nativeObjectId != newPropsValue.nativeObjectId ||
+      oldPropsValue.generation != newPropsValue.generation) {
+    _nativeObjectId = newPropsValue.nativeObjectId;
+    _generation = newPropsValue.generation;
+    [self updateAttachedOutput];
+  }
+  [self applyVideoLayerGeometry];
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  [self applyVideoLayerGeometry];
+}
+
+- (void)prepareForRecycle {
+  [self detachNativeOutput:_attachedObjectId];
+  _nativeObjectId = 0;
+  _generation = 0;
+  _attachedObjectId = 0;
+  _attachedGeneration = 0;
+  [super prepareForRecycle];
+}
+
+- (void)dealloc {
+  [self detachNativeOutput:_attachedObjectId];
+}
+
+- (void)updateAttachedOutput {
+  if (_attachedObjectId > 0 &&
+      (_attachedObjectId != _nativeObjectId || _attachedGeneration != _generation)) {
+    [self detachNativeOutput:_attachedObjectId];
+    _attachedObjectId = 0;
+    _attachedGeneration = 0;
+  }
+  if (_nativeObjectId <= 0 || _generation <= 0 ||
+      (_attachedObjectId == _nativeObjectId && _attachedGeneration == _generation)) {
+    return;
+  }
+  TiRtcReactNativeRegistry* registry = [TiRtcReactNativeRegistry sharedRegistry];
+  if ([registry generationForObjectId:_nativeObjectId] != _generation) {
+    return;
+  }
+  id object = [registry objectForId:_nativeObjectId];
+  if ([object isKindOfClass:[TiRtcVideoOutput class]]) {
+    int32_t code = [(TiRtcVideoOutput*)object attachView:self];
+    if (code != 0) {
+      [registry reportVideoOutputError:_nativeObjectId code:code message:@"view attach failed"];
+      return;
+    }
+    _attachedObjectId = _nativeObjectId;
+    _attachedGeneration = _generation;
+    [self applyVideoLayerGeometry];
+  }
+}
+
+- (void)detachNativeOutput:(NSInteger)objectId {
+  if (objectId <= 0) {
+    return;
+  }
+  id object = [[TiRtcReactNativeRegistry sharedRegistry] objectForId:objectId];
+  if ([object isKindOfClass:[TiRtcVideoOutput class]]) {
+    __unused int32_t code = [(TiRtcVideoOutput*)object detachView];
+  }
+}
+
+- (void)applyVideoLayerGeometry {
+  AVLayerVideoGravity videoGravity = TiRtcVideoOutputGravityForResizeMode(_resizeMode);
+  [CATransaction begin];
+  [CATransaction setDisableActions:YES];
+  for (CALayer* layer in self.layer.sublayers) {
+    if ([layer isKindOfClass:[AVSampleBufferDisplayLayer class]]) {
+      AVSampleBufferDisplayLayer* displayLayer = (AVSampleBufferDisplayLayer*)layer;
+      displayLayer.frame = self.bounds;
+      displayLayer.videoGravity = videoGravity;
+    }
+  }
+  [CATransaction commit];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> TiRtcVideoOutputViewCls(void) {
+  return TiRtcVideoOutputView.class;
+}