tirtc-react-native 2.2.0

package/ios/TiRtcReactNative+Output.mm

@@ -0,0 +1,172 @@
+#import "TiRtcReactNative+Private.h"
+#import "TiRtcReactNativeErrors.h"
+#import "TiRtcReactNativeMaps.h"
+#import "TiRtcReactNativeOptions.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"
+@implementation TiRtcReactNative (Output)
+
+- (NSDictionary*)createAudioOutput {
+  return [self
+      registerObject:^id {
+        return [TiRtcAudioOutput new];
+      }
+      wire:^id(NSInteger objectId, id object) {
+        return [[self eventBinder] wireAudioOutput:(TiRtcAudioOutput*)object objectId:objectId];
+      }];
+}
+
+- (NSDictionary*)audioOutputGetState:(double)objectId {
+  TiRtcAudioOutput* output = [self audioOutput:objectId];
+  if (output == nil) {
+    return TiRtcReactNativeStateResult(TiRtcReactNativeErrorObjectReleased, nil);
+  }
+  return TiRtcReactNativeStateResult(TiRtcReactNativeErrorOK,
+                                     TiRtcReactNativeAudioOutputStateString(output.state));
+}
+
+- (NSNumber*)audioOutputConfigure:(double)objectId
+                          options:(JS::NativeTiRtc::NativeAudioOutputOptions&)options {
+  TiRtcAudioOutputOptions* nativeOptions = TiRtcReactNativeAudioOutputOptions(options);
+  return [self audioOutputCode:[self audioOutput:objectId]
+                         block:^int32_t(TiRtcAudioOutput* output) {
+                           return [output configure:nativeOptions];
+                         }];
+}
+
+- (NSNumber*)audioOutputSetVolume:(double)objectId volumePercent:(double)volumePercent {
+  if (!TiRtcReactNativeIsVolumePercent(volumePercent)) {
+    return @(TiRtcReactNativeErrorInvalidArgument);
+  }
+  return [self audioOutputCode:[self audioOutput:objectId]
+                         block:^int32_t(TiRtcAudioOutput* output) {
+                           return [output setVolume:(uint32_t)volumePercent];
+                         }];
+}
+
+- (NSNumber*)audioOutputAttach:(double)objectId connId:(double)connId streamId:(double)streamId {
+  TiRtcConn* conn = [self conn:connId];
+  if (conn == nil) {
+    return @(TiRtcReactNativeErrorObjectReleased);
+  }
+  return [self audioOutputCode:[self audioOutput:objectId]
+                         block:^int32_t(TiRtcAudioOutput* output) {
+                           return [output attachWithConnection:conn
+                                                      streamId:TiRtcReactNativeStreamId(streamId)];
+                         }];
+}
+
+- (NSNumber*)audioOutputDetach:(double)objectId {
+  return [self audioOutputCode:[self audioOutput:objectId]
+                         block:^int32_t(TiRtcAudioOutput* output) {
+                           return [output detach];
+                         }];
+}
+
+- (NSDictionary*)audioOutputGetMetricsSnapshot:(double)objectId {
+  TiRtcAudioOutput* output = [self audioOutput:objectId];
+  return output == nil ? TiRtcReactNativeReleasedSnapshotResult()
+                       : TiRtcReactNativeAudioMetricsResult([output getMetricsSnapshot]);
+}
+
+- (NSNumber*)audioOutputResetMetricsSession:(double)objectId {
+  return [self audioOutputCode:[self audioOutput:objectId]
+                         block:^int32_t(TiRtcAudioOutput* output) {
+                           return [output resetMetricsSession];
+                         }];
+}
+
+- (NSDictionary*)audioOutputGetDebugSnapshot:(double)objectId {
+  TiRtcAudioOutput* output = [self audioOutput:objectId];
+  return output == nil ? TiRtcReactNativeReleasedSnapshotResult()
+                       : TiRtcReactNativeAudioDebugResult([output getDebugSnapshot]);
+}
+
+- (NSNumber*)audioOutputDispose:(double)objectId {
+  TiRtcAudioOutput* output = [self audioOutput:objectId];
+  [output dispose];
+  return [self releaseRegisteredObject:(NSInteger)objectId object:output];
+}
+
+- (NSDictionary*)createVideoOutput {
+  return [self
+      registerObject:^id {
+        return [TiRtcVideoOutput new];
+      }
+      wire:^id(NSInteger objectId, id object) {
+        return [[self eventBinder] wireVideoOutput:(TiRtcVideoOutput*)object objectId:objectId];
+      }];
+}
+
+- (NSDictionary*)videoOutputGetState:(double)objectId {
+  TiRtcVideoOutput* output = [self videoOutput:objectId];
+  if (output == nil) {
+    return TiRtcReactNativeStateResult(TiRtcReactNativeErrorObjectReleased, nil);
+  }
+  return TiRtcReactNativeStateResult(TiRtcReactNativeErrorOK,
+                                     TiRtcReactNativeVideoOutputStateString(output.state));
+}
+
+- (NSDictionary*)videoOutputGetRenderSize:(double)objectId {
+  TiRtcVideoOutput* output = [self videoOutput:objectId];
+  return output == nil
+             ? TiRtcReactNativeSizeResult(TiRtcReactNativeErrorObjectReleased, CGSizeZero, NO)
+             : TiRtcReactNativeSizeResult(TiRtcReactNativeErrorOK, output.renderSize, YES);
+}
+
+- (NSNumber*)videoOutputSetOptions:(double)objectId
+                           options:(JS::NativeTiRtc::NativeVideoOutputOptions&)options {
+  TiRtcVideoOutputOptions* nativeOptions = TiRtcReactNativeVideoOutputOptions(options);
+  return [self videoOutputCode:[self videoOutput:objectId]
+                         block:^int32_t(TiRtcVideoOutput* output) {
+                           return [output setOptions:nativeOptions];
+                         }];
+}
+
+- (NSNumber*)videoOutputAttach:(double)objectId connId:(double)connId streamId:(double)streamId {
+  TiRtcConn* conn = [self conn:connId];
+  if (conn == nil) {
+    return @(TiRtcReactNativeErrorObjectReleased);
+  }
+  return [self videoOutputCode:[self videoOutput:objectId]
+                         block:^int32_t(TiRtcVideoOutput* output) {
+                           return [output attachWithConnection:conn
+                                                      streamId:TiRtcReactNativeStreamId(streamId)];
+                         }];
+}
+
+- (NSNumber*)videoOutputDetach:(double)objectId {
+  return [self videoOutputCode:[self videoOutput:objectId]
+                         block:^int32_t(TiRtcVideoOutput* output) {
+                           return [output detach];
+                         }];
+}
+
+- (NSDictionary*)videoOutputGetMetricsSnapshot:(double)objectId {
+  TiRtcVideoOutput* output = [self videoOutput:objectId];
+  return output == nil ? TiRtcReactNativeReleasedSnapshotResult()
+                       : TiRtcReactNativeVideoMetricsResult([output getMetricsSnapshot]);
+}
+
+- (NSNumber*)videoOutputResetMetricsSession:(double)objectId {
+  return [self videoOutputCode:[self videoOutput:objectId]
+                         block:^int32_t(TiRtcVideoOutput* output) {
+                           return [output resetMetricsSession];
+                         }];
+}
+
+- (NSDictionary*)videoOutputGetDebugSnapshot:(double)objectId {
+  TiRtcVideoOutput* output = [self videoOutput:objectId];
+  return output == nil ? TiRtcReactNativeReleasedSnapshotResult()
+                       : TiRtcReactNativeVideoDebugResult([output getDebugSnapshot]);
+}
+
+- (NSNumber*)videoOutputDispose:(double)objectId {
+  TiRtcVideoOutput* output = [self videoOutput:objectId];
+  [output dispose];
+  return [self releaseRegisteredObject:(NSInteger)objectId object:output];
+}
+
+@end
+#pragma clang diagnostic pop

package/ios/TiRtcReactNative+Private.h

@@ -0,0 +1,28 @@
+#import "TiRtcReactNative.h"
+#import "TiRtcReactNativeEventBinder.h"
+#import "TiRtcReactNativeNative.h"
+#import "TiRtcReactNativeRegistry.h"
+
+@interface TiRtcReactNative (Private)
+
+- (TiRtcReactNativeRegistry*)registry;
+- (TiRtcReactNativeEventBinder*)eventBinder;
+- (NSDictionary*)registerObject:(id (^)(void))factory
+                           wire:(id (^)(NSInteger objectId, id object))wire;
+- (NSNumber*)releaseRegisteredObject:(NSInteger)objectId object:(id)object;
+- (NSNumber*)connCode:(TiRtcConn*)conn block:(int32_t (^)(TiRtcConn* conn))block;
+- (NSNumber*)audioOutputCode:(TiRtcAudioOutput*)output
+                       block:(int32_t (^)(TiRtcAudioOutput* output))block;
+- (NSNumber*)videoOutputCode:(TiRtcVideoOutput*)output
+                       block:(int32_t (^)(TiRtcVideoOutput* output))block;
+- (NSNumber*)audioInputCode:(TiRtcAudioInput*)input
+                      block:(int32_t (^)(TiRtcAudioInput* input))block;
+- (NSNumber*)videoInputCode:(TiRtcVideoInput*)input
+                      block:(int32_t (^)(TiRtcVideoInput* input))block;
+- (TiRtcConn*)conn:(double)objectId;
+- (TiRtcAudioOutput*)audioOutput:(double)objectId;
+- (TiRtcVideoOutput*)videoOutput:(double)objectId;
+- (TiRtcAudioInput*)audioInput:(double)objectId;
+- (TiRtcVideoInput*)videoInput:(double)objectId;
+
+@end

package/ios/TiRtcReactNative.h

@@ -0,0 +1,6 @@
+#import <Foundation/Foundation.h>
+
+#import "TiRtcSpec.h"
+
+@interface TiRtcReactNative : NativeTiRtcSpecBase <NativeTiRtcSpec>
+@end

package/ios/TiRtcReactNative.mm

@@ -0,0 +1,189 @@
+#import "TiRtcReactNative.h"
+
+#import <React/RCTBridgeModule.h>
+
+#import <memory>
+
+#import "TiRtcReactNativeErrors.h"
+#import "TiRtcReactNativeEventBinder.h"
+#import "TiRtcReactNativeEventSink.h"
+#import "TiRtcReactNativeMaps.h"
+#import "TiRtcReactNativeNative.h"
+#import "TiRtcReactNativeOptions.h"
+#import "TiRtcReactNativeRegistry.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wprotocol"
+@implementation TiRtcReactNative {
+  TiRtcReactNativeRegistry* _registry;
+  TiRtcReactNativeEventSink* _eventSink;
+  TiRtcReactNativeEventBinder* _eventBinder;
+}
+
+RCT_EXPORT_MODULE(TiRtc)
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _registry = [TiRtcReactNativeRegistry sharedRegistry];
+    __weak TiRtcReactNative* weakSelf = self;
+    _eventSink = [[TiRtcReactNativeEventSink alloc] initWithRegistry:_registry
+                                                           emitBlock:^(NSDictionary* event) {
+                                                             [weakSelf emitOnTiRtcEvent:event];
+                                                           }];
+    [_registry setEventSink:_eventSink];
+    _eventBinder = [[TiRtcReactNativeEventBinder alloc] initWithEventSink:_eventSink];
+  }
+  return self;
+}
+
+- (void)initialize:(JS::NativeTiRtc::NativeInitOptions&)options
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject {
+  TiRtcInitOptions* config = [TiRtcInitOptions new];
+  config.appId = options.appId() ?: @"";
+  config.endpoint = options.endpoint() ?: @"";
+  config.consoleLogEnabled = options.consoleLogEnabled();
+  resolve(@(TiRtcReactNativeNormalizeDarwin([TiRtc initialize:config])));
+}
+
+- (NSNumber*)shutdown {
+  if ([_registry hasLiveObjects]) {
+    return @(TiRtcReactNativeErrorRuntimeObjectsLive);
+  }
+  return @(TiRtcReactNativeNormalizeDarwin([TiRtc shutdown]));
+}
+
+- (NSString*)errorToString:(double)code {
+  return [TiRtc errorToString:(int32_t)code];
+}
+
+- (void)writeLog:(double)level tag:(NSString*)tag message:(NSString*)message {
+  NSInteger nativeLevel = 0;
+  switch ((NSInteger)level) {
+    case 0:
+      nativeLevel = 1;
+      break;
+    case 1:
+      nativeLevel = 2;
+      break;
+    case 2:
+      nativeLevel = 3;
+      break;
+    case 3:
+      nativeLevel = 4;
+      break;
+    default:
+      return;
+  }
+  [TiRtcLogging logWithLevel:(TiRtcLogLevel)nativeLevel tag:tag message:message];
+}
+
+- (void)uploadLogs:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  int32_t startCode = [TiRtcLogging uploadWithCompletion:^(TiRtcLogUploadResult* result) {
+    resolve(@{
+      @"code" : @(TiRtcReactNativeNormalizeDarwin(result.code)),
+      @"logId" : result.logId ?: (id)kCFNull,
+    });
+  }];
+  if (startCode != 0) {
+    resolve(@{
+      @"code" : @(TiRtcReactNativeNormalizeDarwin(startCode)),
+      @"logId" : (id)kCFNull,
+    });
+  }
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams&)params {
+  return std::make_shared<facebook::react::NativeTiRtcSpecJSI>(params);
+}
+
+- (NSDictionary*)registerObject:(id (^)(void))factory
+                           wire:(id (^)(NSInteger objectId, id object))wire {
+  @try {
+    id object = factory();
+    NSInteger generation = 0;
+    NSInteger objectId = [_registry addObject:object generation:&generation];
+    id delegate = wire != nil ? wire(objectId, object) : nil;
+    if (delegate != nil) {
+      [_registry setDelegate:delegate forObjectId:objectId];
+    }
+    return TiRtcReactNativeCreateResult(TiRtcReactNativeErrorOK, objectId, generation, nil);
+  } @catch (NSException* exception) {
+    return TiRtcReactNativeCreateResult(TiRtcReactNativeErrorPlatformInternal, 0, 0,
+                                        exception.reason);
+  }
+}
+
+- (TiRtcReactNativeRegistry*)registry {
+  return _registry;
+}
+
+- (TiRtcReactNativeEventBinder*)eventBinder {
+  return _eventBinder;
+}
+
+- (NSNumber*)releaseRegisteredObject:(NSInteger)objectId object:(id)object {
+  if (object == nil) {
+    return @(TiRtcReactNativeErrorObjectReleased);
+  }
+  [_registry releaseObject:objectId];
+  return @(TiRtcReactNativeErrorOK);
+}
+
+- (NSNumber*)connCode:(TiRtcConn*)conn block:(int32_t (^)(TiRtcConn* conn))block {
+  return conn == nil ? @(TiRtcReactNativeErrorObjectReleased)
+                     : @(TiRtcReactNativeNormalizeDarwin(block(conn)));
+}
+
+- (NSNumber*)audioOutputCode:(TiRtcAudioOutput*)output
+                       block:(int32_t (^)(TiRtcAudioOutput* output))block {
+  return output == nil ? @(TiRtcReactNativeErrorObjectReleased)
+                       : @(TiRtcReactNativeNormalizeDarwin(block(output)));
+}
+
+- (NSNumber*)videoOutputCode:(TiRtcVideoOutput*)output
+                       block:(int32_t (^)(TiRtcVideoOutput* output))block {
+  return output == nil ? @(TiRtcReactNativeErrorObjectReleased)
+                       : @(TiRtcReactNativeNormalizeDarwin(block(output)));
+}
+
+- (NSNumber*)audioInputCode:(TiRtcAudioInput*)input
+                      block:(int32_t (^)(TiRtcAudioInput* input))block {
+  return input == nil ? @(TiRtcReactNativeErrorObjectReleased)
+                      : @(TiRtcReactNativeNormalizeDarwin(block(input)));
+}
+
+- (NSNumber*)videoInputCode:(TiRtcVideoInput*)input
+                      block:(int32_t (^)(TiRtcVideoInput* input))block {
+  return input == nil ? @(TiRtcReactNativeErrorObjectReleased)
+                      : @(TiRtcReactNativeNormalizeDarwin(block(input)));
+}
+
+- (TiRtcConn*)conn:(double)objectId {
+  id object = [_registry objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiRtcConn class]] ? (TiRtcConn*)object : nil;
+}
+
+- (TiRtcAudioOutput*)audioOutput:(double)objectId {
+  id object = [_registry objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiRtcAudioOutput class]] ? (TiRtcAudioOutput*)object : nil;
+}
+
+- (TiRtcVideoOutput*)videoOutput:(double)objectId {
+  id object = [_registry objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiRtcVideoOutput class]] ? (TiRtcVideoOutput*)object : nil;
+}
+
+- (TiRtcAudioInput*)audioInput:(double)objectId {
+  id object = [_registry objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiRtcAudioInput class]] ? (TiRtcAudioInput*)object : nil;
+}
+
+- (TiRtcVideoInput*)videoInput:(double)objectId {
+  id object = [_registry objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiRtcVideoInput class]] ? (TiRtcVideoInput*)object : nil;
+}
+
+@end
+#pragma clang diagnostic pop

package/ios/TiRtcReactNativeErrors.h

@@ -0,0 +1,18 @@
+#import <CoreGraphics/CoreGraphics.h>
+#import <Foundation/Foundation.h>
+
+extern const NSInteger TiRtcReactNativeErrorOK;
+extern const NSInteger TiRtcReactNativeErrorInvalidArgument;
+extern const NSInteger TiRtcReactNativeErrorObjectReleased;
+extern const NSInteger TiRtcReactNativeErrorPlatformInternal;
+extern const NSInteger TiRtcReactNativeErrorRuntimeObjectsLive;
+
+NSInteger TiRtcReactNativeNormalizeDarwin(int32_t code);
+NSString* TiRtcReactNativeConnStateString(NSInteger state);
+NSString* TiRtcReactNativeInputStateString(NSInteger state);
+NSString* TiRtcReactNativeAudioOutputStateString(NSInteger state);
+NSString* TiRtcReactNativeVideoOutputStateString(NSInteger state);
+uint8_t TiRtcReactNativeStreamId(double value);
+uint32_t TiRtcReactNativeUInt32(double value);
+BOOL TiRtcReactNativeIsVolumePercent(double value);
+NSNumber* TiRtcReactNativeNullableNumberFromOptionalDouble(BOOL hasValue, double value);

package/ios/TiRtcReactNativeErrors.mm

@@ -0,0 +1,105 @@
+#import "TiRtcReactNativeErrors.h"
+#include <cmath>
+
+const NSInteger TiRtcReactNativeErrorOK = 0;
+const NSInteger TiRtcReactNativeErrorInvalidArgument = 6000;
+const NSInteger TiRtcReactNativeErrorObjectReleased = 1008;
+const NSInteger TiRtcReactNativeErrorPlatformInternal = 1001;
+const NSInteger TiRtcReactNativeErrorRuntimeObjectsLive = 1007;
+
+NSInteger TiRtcReactNativeNormalizeDarwin(int32_t code) {
+  switch (code) {
+    case 1002:
+      return TiRtcReactNativeErrorInvalidArgument;
+    case 1011:
+      return 1301;
+    case 1012:
+      return 1302;
+    case 1013:
+      return 1303;
+    case 1014:
+      return 6024;
+    default:
+      return code;
+  }
+}
+
+NSString* TiRtcReactNativeConnStateString(NSInteger state) {
+  switch (state) {
+    case 1:
+      return @"connecting";
+    case 2:
+      return @"connected";
+    case 3:
+      return @"disconnected";
+    default:
+      return @"idle";
+  }
+}
+
+NSString* TiRtcReactNativeInputStateString(NSInteger state) {
+  switch (state) {
+    case 1:
+      return @"running";
+    case 2:
+      return @"stopped";
+    case 3:
+      return @"failed";
+    default:
+      return @"idle";
+  }
+}
+
+NSString* TiRtcReactNativeAudioOutputStateString(NSInteger state) {
+  switch (state) {
+    case 1:
+      return @"buffering";
+    case 2:
+      return @"playing";
+    case 3:
+      return @"failed";
+    default:
+      return @"idle";
+  }
+}
+
+NSString* TiRtcReactNativeVideoOutputStateString(NSInteger state) {
+  switch (state) {
+    case 1:
+      return @"buffering";
+    case 2:
+      return @"rendering";
+    case 3:
+      return @"failed";
+    default:
+      return @"idle";
+  }
+}
+
+uint8_t TiRtcReactNativeStreamId(double value) {
+  if (value < 0) {
+    return 0;
+  }
+  if (value > UINT8_MAX) {
+    return UINT8_MAX;
+  }
+  return (uint8_t)value;
+}
+
+uint32_t TiRtcReactNativeUInt32(double value) {
+  if (value < 0) {
+    return 0;
+  }
+  if (value > UINT32_MAX) {
+    return UINT32_MAX;
+  }
+  return (uint32_t)value;
+}
+
+BOOL TiRtcReactNativeIsVolumePercent(double value) {
+  return std::isfinite(value) && value >= 0 && value <= 100 && std::trunc(value) == value;
+}
+
+NSNumber* TiRtcReactNativeNullableNumberFromOptionalDouble(BOOL hasValue, double value) {
+  return hasValue ? @(value) : (NSNumber*)nil;
+}

package/ios/TiRtcReactNativeEventBinder.h

@@ -0,0 +1,19 @@
+#import <Foundation/Foundation.h>
+
+@class TiRtcAudioInput;
+@class TiRtcAudioOutput;
+@class TiRtcConn;
+@class TiRtcReactNativeEventSink;
+@class TiRtcVideoInput;
+@class TiRtcVideoOutput;
+
+@interface TiRtcReactNativeEventBinder : NSObject
+
+- (instancetype)initWithEventSink:(TiRtcReactNativeEventSink*)eventSink;
+- (id)wireConn:(TiRtcConn*)conn objectId:(NSInteger)objectId;
+- (id)wireAudioOutput:(TiRtcAudioOutput*)output objectId:(NSInteger)objectId;
+- (id)wireVideoOutput:(TiRtcVideoOutput*)output objectId:(NSInteger)objectId;
+- (id)wireAudioInput:(TiRtcAudioInput*)input objectId:(NSInteger)objectId;
+- (id)wireVideoInput:(TiRtcVideoInput*)input objectId:(NSInteger)objectId;
+
+@end