tirtc-react-native 2.2.0

package/ios/TiRtcReactNativeEventBinder.mm

@@ -0,0 +1,226 @@
+#import "TiRtcReactNativeEventBinder.h"
+
+#import "TiRtcReactNativeErrors.h"
+#import "TiRtcReactNativeEventSink.h"
+#import "TiRtcReactNativeNative.h"
+#import "TiRtcReactNativeRegistry.h"
+
+@interface TiRtcReactNativeConnDelegate : NSObject <TiRtcConnDelegate>
+- (instancetype)initWithObjectId:(NSInteger)objectId
+                       eventSink:(TiRtcReactNativeEventSink*)eventSink;
+@end
+
+@implementation TiRtcReactNativeConnDelegate {
+  NSInteger _objectId;
+  TiRtcReactNativeEventSink* _eventSink;
+}
+
+- (instancetype)initWithObjectId:(NSInteger)objectId
+                       eventSink:(TiRtcReactNativeEventSink*)eventSink {
+  if (self = [super init]) {
+    _objectId = objectId;
+    _eventSink = eventSink;
+  }
+  return self;
+}
+
+- (void)conn:(TiRtcConn*)conn didChangeState:(TiRtcConnState)state errorCode:(int32_t)errorCode {
+  [_eventSink connStateChanged:_objectId
+                         state:TiRtcReactNativeConnStateString(state)
+                     errorCode:errorCode];
+}
+
+- (void)conn:(TiRtcConn*)conn didReceiveCommand:(uint32_t)commandId data:(NSData*)data {
+  [_eventSink connCommand:_objectId commandId:commandId data:data];
+}
+
+- (void)conn:(TiRtcConn*)conn
+    didReceiveStreamMessage:(uint8_t)streamId
+                timestampMs:(uint32_t)timestampMs
+                       data:(NSData*)data {
+  [_eventSink connStreamMessage:_objectId streamId:streamId timestampMs:timestampMs data:data];
+}
+
+@end
+
+@interface TiRtcReactNativeAudioOutputDelegate : NSObject <TiRtcAudioOutputDelegate>
+- (instancetype)initWithObjectId:(NSInteger)objectId
+                       eventSink:(TiRtcReactNativeEventSink*)eventSink;
+@end
+
+@implementation TiRtcReactNativeAudioOutputDelegate {
+  NSInteger _objectId;
+  TiRtcReactNativeEventSink* _eventSink;
+}
+
+- (instancetype)initWithObjectId:(NSInteger)objectId
+                       eventSink:(TiRtcReactNativeEventSink*)eventSink {
+  if (self = [super init]) {
+    _objectId = objectId;
+    _eventSink = eventSink;
+  }
+  return self;
+}
+
+- (void)audioOutput:(TiRtcAudioOutput*)output didChangeState:(TiRtcAudioOutputState)state {
+  [_eventSink audioOutputStateChanged:_objectId
+                                state:TiRtcReactNativeAudioOutputStateString(state)];
+}
+
+- (void)audioOutput:(TiRtcAudioOutput*)output
+    didFailWithCode:(int32_t)code
+            message:(NSString*)message {
+  [_eventSink audioOutputError:_objectId code:code message:message];
+}
+
+@end
+
+@interface TiRtcReactNativeVideoOutputDelegate : NSObject <TiRtcVideoOutputDelegate>
+- (instancetype)initWithObjectId:(NSInteger)objectId
+                       eventSink:(TiRtcReactNativeEventSink*)eventSink;
+@end
+
+@implementation TiRtcReactNativeVideoOutputDelegate {
+  NSInteger _objectId;
+  TiRtcReactNativeEventSink* _eventSink;
+}
+
+- (instancetype)initWithObjectId:(NSInteger)objectId
+                       eventSink:(TiRtcReactNativeEventSink*)eventSink {
+  if (self = [super init]) {
+    _objectId = objectId;
+    _eventSink = eventSink;
+  }
+  return self;
+}
+
+- (void)videoOutput:(TiRtcVideoOutput*)output didChangeState:(TiRtcVideoOutputState)state {
+  [_eventSink videoOutputStateChanged:_objectId
+                                state:TiRtcReactNativeVideoOutputStateString(state)];
+}
+
+- (void)videoOutput:(TiRtcVideoOutput*)output didChangeRenderSize:(CGSize)size {
+  [_eventSink videoOutputRenderSizeChanged:_objectId size:size];
+}
+
+- (void)videoOutput:(TiRtcVideoOutput*)output
+    didFailWithCode:(int32_t)code
+            message:(NSString*)message {
+  [_eventSink videoOutputError:_objectId code:code message:message];
+}
+
+@end
+
+@interface TiRtcReactNativeAudioInputDelegate : NSObject <TiRtcAudioInputDelegate>
+- (instancetype)initWithObjectId:(NSInteger)objectId
+                       eventSink:(TiRtcReactNativeEventSink*)eventSink;
+@end
+
+@implementation TiRtcReactNativeAudioInputDelegate {
+  NSInteger _objectId;
+  TiRtcReactNativeEventSink* _eventSink;
+}
+
+- (instancetype)initWithObjectId:(NSInteger)objectId
+                       eventSink:(TiRtcReactNativeEventSink*)eventSink {
+  if (self = [super init]) {
+    _objectId = objectId;
+    _eventSink = eventSink;
+  }
+  return self;
+}
+
+- (void)audioInput:(TiRtcAudioInput*)input didChangeState:(TiRtcInputState)state {
+  [_eventSink audioInputStateChanged:_objectId state:TiRtcReactNativeInputStateString(state)];
+}
+
+- (void)audioInput:(TiRtcAudioInput*)input
+    didFailWithCode:(int32_t)code
+            message:(NSString*)message {
+  [_eventSink audioInputError:_objectId code:code message:message];
+}
+
+@end
+
+@interface TiRtcReactNativeVideoInputDelegate : NSObject <TiRtcVideoInputDelegate>
+- (instancetype)initWithObjectId:(NSInteger)objectId
+                       eventSink:(TiRtcReactNativeEventSink*)eventSink;
+@end
+
+@implementation TiRtcReactNativeVideoInputDelegate {
+  NSInteger _objectId;
+  TiRtcReactNativeEventSink* _eventSink;
+}
+
+- (instancetype)initWithObjectId:(NSInteger)objectId
+                       eventSink:(TiRtcReactNativeEventSink*)eventSink {
+  if (self = [super init]) {
+    _objectId = objectId;
+    _eventSink = eventSink;
+  }
+  return self;
+}
+
+- (void)videoInput:(TiRtcVideoInput*)input didChangeState:(TiRtcInputState)state {
+  [_eventSink videoInputStateChanged:_objectId state:TiRtcReactNativeInputStateString(state)];
+}
+
+- (void)videoInput:(TiRtcVideoInput*)input didChangeActualConfig:(CGSize)size fps:(int32_t)fps {
+  [_eventSink videoInputActualConfigChanged:_objectId size:size fps:fps];
+}
+
+- (void)videoInput:(TiRtcVideoInput*)input
+    didFailWithCode:(int32_t)code
+            message:(NSString*)message {
+  [_eventSink videoInputError:_objectId code:code message:message];
+}
+
+@end
+
+@implementation TiRtcReactNativeEventBinder {
+  TiRtcReactNativeEventSink* _eventSink;
+}
+
+- (instancetype)initWithEventSink:(TiRtcReactNativeEventSink*)eventSink {
+  if (self = [super init]) {
+    _eventSink = eventSink;
+  }
+  return self;
+}
+
+- (id)wireConn:(TiRtcConn*)conn objectId:(NSInteger)objectId {
+  TiRtcReactNativeConnDelegate* delegate =
+      [[TiRtcReactNativeConnDelegate alloc] initWithObjectId:objectId eventSink:_eventSink];
+  conn.delegate = delegate;
+  return delegate;
+}
+
+- (id)wireAudioOutput:(TiRtcAudioOutput*)output objectId:(NSInteger)objectId {
+  TiRtcReactNativeAudioOutputDelegate* delegate =
+      [[TiRtcReactNativeAudioOutputDelegate alloc] initWithObjectId:objectId eventSink:_eventSink];
+  output.delegate = delegate;
+  return delegate;
+}
+
+- (id)wireVideoOutput:(TiRtcVideoOutput*)output objectId:(NSInteger)objectId {
+  TiRtcReactNativeVideoOutputDelegate* delegate =
+      [[TiRtcReactNativeVideoOutputDelegate alloc] initWithObjectId:objectId eventSink:_eventSink];
+  output.delegate = delegate;
+  return delegate;
+}
+
+- (id)wireAudioInput:(TiRtcAudioInput*)input objectId:(NSInteger)objectId {
+  TiRtcReactNativeAudioInputDelegate* delegate =
+      [[TiRtcReactNativeAudioInputDelegate alloc] initWithObjectId:objectId eventSink:_eventSink];
+  input.delegate = delegate;
+  return delegate;
+}
+
+- (id)wireVideoInput:(TiRtcVideoInput*)input objectId:(NSInteger)objectId {
+  TiRtcReactNativeVideoInputDelegate* delegate =
+      [[TiRtcReactNativeVideoInputDelegate alloc] initWithObjectId:objectId eventSink:_eventSink];
+  input.delegate = delegate;
+  return delegate;
+}
+
+@end

package/ios/TiRtcReactNativeEventSink.h

@@ -0,0 +1,29 @@
+#import <CoreGraphics/CoreGraphics.h>
+#import <Foundation/Foundation.h>
+
+typedef void (^TiRtcReactNativeEmitBlock)(NSDictionary* event);
+
+@class TiRtcReactNativeRegistry;
+
+@interface TiRtcReactNativeEventSink : NSObject
+
+- (instancetype)initWithRegistry:(TiRtcReactNativeRegistry*)registry
+                       emitBlock:(TiRtcReactNativeEmitBlock)emitBlock;
+- (void)connStateChanged:(NSInteger)objectId state:(NSString*)state errorCode:(int32_t)errorCode;
+- (void)connCommand:(NSInteger)objectId commandId:(uint32_t)commandId data:(NSData*)data;
+- (void)connStreamMessage:(NSInteger)objectId
+                 streamId:(uint8_t)streamId
+              timestampMs:(uint32_t)timestampMs
+                     data:(NSData*)data;
+- (void)audioOutputStateChanged:(NSInteger)objectId state:(NSString*)state;
+- (void)audioOutputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message;
+- (void)videoOutputStateChanged:(NSInteger)objectId state:(NSString*)state;
+- (void)videoOutputRenderSizeChanged:(NSInteger)objectId size:(CGSize)size;
+- (void)videoOutputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message;
+- (void)audioInputStateChanged:(NSInteger)objectId state:(NSString*)state;
+- (void)audioInputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message;
+- (void)videoInputStateChanged:(NSInteger)objectId state:(NSString*)state;
+- (void)videoInputActualConfigChanged:(NSInteger)objectId size:(CGSize)size fps:(int32_t)fps;
+- (void)videoInputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message;
+
+@end

package/ios/TiRtcReactNativeEventSink.mm

@@ -0,0 +1,125 @@
+#import "TiRtcReactNativeEventSink.h"
+
+#import "TiRtcReactNativeErrors.h"
+#import "TiRtcReactNativeMaps.h"
+#import "TiRtcReactNativeRegistry.h"
+
+@implementation TiRtcReactNativeEventSink {
+  TiRtcReactNativeRegistry* _registry;
+  TiRtcReactNativeEmitBlock _emitBlock;
+}
+
+- (instancetype)initWithRegistry:(TiRtcReactNativeRegistry*)registry
+                       emitBlock:(TiRtcReactNativeEmitBlock)emitBlock {
+  if (self = [super init]) {
+    _registry = registry;
+    _emitBlock = [emitBlock copy];
+  }
+  return self;
+}
+
+- (void)connStateChanged:(NSInteger)objectId state:(NSString*)state errorCode:(int32_t)errorCode {
+  NSMutableDictionary* event = [self base:@"connStateChanged" objectId:objectId];
+  event[@"state"] = state;
+  event[@"errorCode"] = @(TiRtcReactNativeNormalizeDarwin(errorCode));
+  [self emit:event];
+}
+
+- (void)connCommand:(NSInteger)objectId commandId:(uint32_t)commandId data:(NSData*)data {
+  NSMutableDictionary* event = [self base:@"connCommand" objectId:objectId];
+  event[@"commandId"] = @(commandId);
+  event[@"data"] = TiRtcReactNativeByteArray(data);
+  [self emit:event];
+}
+
+- (void)connStreamMessage:(NSInteger)objectId
+                 streamId:(uint8_t)streamId
+              timestampMs:(uint32_t)timestampMs
+                     data:(NSData*)data {
+  NSMutableDictionary* event = [self base:@"connStreamMessage" objectId:objectId];
+  event[@"streamId"] = @(streamId);
+  event[@"timestampMs"] = @(timestampMs);
+  event[@"data"] = TiRtcReactNativeByteArray(data);
+  [self emit:event];
+}
+
+- (void)audioOutputStateChanged:(NSInteger)objectId state:(NSString*)state {
+  NSMutableDictionary* event = [self base:@"audioOutputStateChanged" objectId:objectId];
+  event[@"state"] = state;
+  [self emit:event];
+}
+
+- (void)audioOutputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message {
+  NSMutableDictionary* event = [self base:@"audioOutputError" objectId:objectId];
+  event[@"code"] = @(TiRtcReactNativeNormalizeDarwin(code));
+  event[@"message"] = message ?: (id)kCFNull;
+  [self emit:event];
+}
+
+- (void)videoOutputStateChanged:(NSInteger)objectId state:(NSString*)state {
+  NSMutableDictionary* event = [self base:@"videoOutputStateChanged" objectId:objectId];
+  event[@"state"] = state;
+  [self emit:event];
+}
+
+- (void)videoOutputRenderSizeChanged:(NSInteger)objectId size:(CGSize)size {
+  NSMutableDictionary* event = [self base:@"videoOutputRenderSizeChanged" objectId:objectId];
+  event[@"size"] = @{@"width" : @((NSInteger)size.width), @"height" : @((NSInteger)size.height)};
+  [self emit:event];
+}
+
+- (void)videoOutputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message {
+  NSMutableDictionary* event = [self base:@"videoOutputError" objectId:objectId];
+  event[@"code"] = @(TiRtcReactNativeNormalizeDarwin(code));
+  event[@"message"] = message ?: (id)kCFNull;
+  [self emit:event];
+}
+
+- (void)audioInputStateChanged:(NSInteger)objectId state:(NSString*)state {
+  NSMutableDictionary* event = [self base:@"audioInputStateChanged" objectId:objectId];
+  event[@"state"] = state;
+  [self emit:event];
+}
+
+- (void)audioInputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message {
+  NSMutableDictionary* event = [self base:@"audioInputError" objectId:objectId];
+  event[@"code"] = @(TiRtcReactNativeNormalizeDarwin(code));
+  event[@"message"] = message ?: (id)kCFNull;
+  [self emit:event];
+}
+
+- (void)videoInputStateChanged:(NSInteger)objectId state:(NSString*)state {
+  NSMutableDictionary* event = [self base:@"videoInputStateChanged" objectId:objectId];
+  event[@"state"] = state;
+  [self emit:event];
+}
+
+- (void)videoInputActualConfigChanged:(NSInteger)objectId size:(CGSize)size fps:(int32_t)fps {
+  NSMutableDictionary* event = [self base:@"videoInputActualConfigChanged" objectId:objectId];
+  event[@"size"] = @{@"width" : @((NSInteger)size.width), @"height" : @((NSInteger)size.height)};
+  event[@"fps"] = @(fps);
+  [self emit:event];
+}
+
+- (void)videoInputError:(NSInteger)objectId code:(int32_t)code message:(NSString*)message {
+  NSMutableDictionary* event = [self base:@"videoInputError" objectId:objectId];
+  event[@"code"] = @(TiRtcReactNativeNormalizeDarwin(code));
+  event[@"message"] = message ?: (id)kCFNull;
+  [self emit:event];
+}
+
+- (NSMutableDictionary*)base:(NSString*)type objectId:(NSInteger)objectId {
+  return [@{
+    @"type" : type,
+    @"objectId" : @(objectId),
+    @"generation" : @([_registry generationForObjectId:objectId]),
+  } mutableCopy];
+}
+
+- (void)emit:(NSDictionary*)event {
+  if (_emitBlock != nil) {
+    _emitBlock(event);
+  }
+}
+
+@end

package/ios/TiRtcReactNativeMaps.h

@@ -0,0 +1,21 @@
+#import <CoreGraphics/CoreGraphics.h>
+#import <Foundation/Foundation.h>
+
+@class TiRtcAudioOutputDebugSnapshotResult;
+@class TiRtcAudioOutputMetricsResult;
+@class TiRtcConnMetricsResult;
+@class TiRtcVideoOutputDebugSnapshotResult;
+@class TiRtcVideoOutputMetricsResult;
+
+NSDictionary* TiRtcReactNativeCreateResult(NSInteger code, NSInteger objectId, NSInteger generation,
+                                           NSString* message);
+NSDictionary* TiRtcReactNativeStateResult(NSInteger code, NSString* state);
+NSDictionary* TiRtcReactNativeSizeResult(NSInteger code, CGSize size, BOOL hasSize);
+NSDictionary* TiRtcReactNativeConnMetricsResult(TiRtcConnMetricsResult* result);
+NSDictionary* TiRtcReactNativeAudioMetricsResult(TiRtcAudioOutputMetricsResult* result);
+NSDictionary* TiRtcReactNativeVideoMetricsResult(TiRtcVideoOutputMetricsResult* result);
+NSDictionary* TiRtcReactNativeAudioDebugResult(TiRtcAudioOutputDebugSnapshotResult* result);
+NSDictionary* TiRtcReactNativeVideoDebugResult(TiRtcVideoOutputDebugSnapshotResult* result);
+NSDictionary* TiRtcReactNativeReleasedSnapshotResult(void);
+NSArray<NSNumber*>* TiRtcReactNativeByteArray(NSData* data);
+NSData* TiRtcReactNativeDataFromArray(NSArray* array);

package/ios/TiRtcReactNativeMaps.mm

@@ -0,0 +1,249 @@
+#import "TiRtcReactNativeMaps.h"
+
+#import "TiRtcReactNativeErrors.h"
+#import "TiRtcReactNativeNative.h"
+
+static NSDictionary* TiRtcReactNativeSizeMap(CGSize size) {
+  return @{
+    @"width" : @((NSInteger)size.width),
+    @"height" : @((NSInteger)size.height),
+  };
+}
+
+static NSDictionary* TiRtcReactNativeSnapshotResult(NSInteger code, NSDictionary* snapshot) {
+  return @{
+    @"code" : @(TiRtcReactNativeNormalizeDarwin((int32_t)code)),
+    @"snapshot" : snapshot ?: (id)kCFNull,
+  };
+}
+
+static id TiRtcReactNativeAudioCodec(NSInteger codec) {
+  switch (codec) {
+    case 1:
+      return @"g711a";
+    case 2:
+      return @"aac";
+    case 3:
+      return @"pcm";
+    case 4:
+      return @"opus";
+    case 5:
+      return @"amr";
+    default:
+      return (id)kCFNull;
+  }
+}
+
+static id TiRtcReactNativeVideoCodec(NSInteger codec) {
+  switch (codec) {
+    case 65:
+      return @"h264";
+    case 66:
+      return @"h265";
+    case 67:
+      return @"mjpeg";
+    default:
+      return (id)kCFNull;
+  }
+}
+
+static NSString* TiRtcReactNativeDecoderBackend(NSInteger backend) {
+  switch (backend) {
+    case 1:
+      return @"software";
+    case 2:
+      return @"hardware";
+    default:
+      return @"unknown";
+  }
+}
+
+static NSString* TiRtcReactNativeDecoderPreference(NSInteger preference) {
+  switch (preference) {
+    case 1:
+      return @"software";
+    case 2:
+      return @"hardware";
+    default:
+      return @"auto";
+  }
+}
+
+static NSString* TiRtcReactNativeBitstreamFormat(NSInteger format) {
+  switch (format) {
+    case 1:
+      return @"h264AnnexB";
+    case 2:
+      return @"h265AnnexB";
+    case 3:
+      return @"mjpegJfif";
+    default:
+      return @"unknown";
+  }
+}
+
+static NSDictionary* TiRtcReactNativeStutter(TiRtcOutputStutterMetrics* metrics) {
+  return @{
+    @"stutterThresholdMs" : @(metrics.stutterThresholdMs),
+    @"outputDurationMs" : @(metrics.outputDurationMs),
+    @"stutterTotalMs" : @(metrics.stutterTotalMs),
+    @"stutterCount" : @(metrics.stutterCount),
+    @"stutterPeakMs" : @(metrics.stutterPeakMs),
+    @"stutterAverageMs" : @(metrics.stutterAverageMs),
+    @"stutterRatePercent" : @(metrics.stutterRate),
+  };
+}
+
+static NSDictionary* TiRtcReactNativeStartup(TiRtcOutputStartupMetrics* metrics) {
+  return @{
+    @"hasConnectStart" : @(metrics.hasConnectStart),
+    @"hasConnected" : @(metrics.hasConnected),
+    @"hasFirstPacket" : @(metrics.hasFirstPacket),
+    @"hasFirstOutput" : @(metrics.hasFirstOutput),
+    @"connectStartMonotonicMs" : @(metrics.connectStartMonotonicMs),
+    @"connectedMonotonicMs" : @(metrics.connectedMonotonicMs),
+    @"firstPacketMonotonicMs" : @(metrics.firstPacketMonotonicMs),
+    @"firstOutputMonotonicMs" : @(metrics.firstOutputMonotonicMs),
+    @"firstPacketAfterConnectedMs" : @(metrics.firstPacketAfterConnectedMs),
+    @"firstOutputAfterConnectedMs" : @(metrics.firstOutputAfterConnectedMs),
+    @"timeToFirstOutputMs" : @(metrics.timeToFirstOutputMs),
+  };
+}
+
+NSDictionary* TiRtcReactNativeCreateResult(NSInteger code, NSInteger objectId, NSInteger generation,
+                                           NSString* message) {
+  return @{
+    @"code" : @(TiRtcReactNativeNormalizeDarwin((int32_t)code)),
+    @"objectId" : @(objectId),
+    @"generation" : @(generation),
+    @"message" : message ?: (id)kCFNull,
+  };
+}
+
+NSDictionary* TiRtcReactNativeStateResult(NSInteger code, NSString* state) {
+  return @{
+    @"code" : @(TiRtcReactNativeNormalizeDarwin((int32_t)code)),
+    @"state" : state ?: (id)kCFNull,
+  };
+}
+
+NSDictionary* TiRtcReactNativeSizeResult(NSInteger code, CGSize size, BOOL hasSize) {
+  return @{
+    @"code" : @(TiRtcReactNativeNormalizeDarwin((int32_t)code)),
+    @"size" : hasSize ? TiRtcReactNativeSizeMap(size) : (id)kCFNull,
+  };
+}
+
+NSDictionary* TiRtcReactNativeConnMetricsResult(TiRtcConnMetricsResult* result) {
+  TiRtcConnMetricsSnapshot* snapshot = result.snapshot;
+  NSDictionary* snapshotMap = nil;
+  if (snapshot != nil) {
+    NSNumber* duration = snapshot.isReady
+                             ? @(snapshot.connectedMonotonicMs - snapshot.connectStartMonotonicMs)
+                             : (NSNumber*)nil;
+    snapshotMap = @{
+      @"hasConnectStart" : @(snapshot.hasConnectStart),
+      @"hasConnected" : @(snapshot.hasConnected),
+      @"connectStartMonotonicMs" : @(snapshot.connectStartMonotonicMs),
+      @"connectedMonotonicMs" : @(snapshot.connectedMonotonicMs),
+      @"isReady" : @(snapshot.isReady),
+      @"connectDurationMs" : duration ?: (id)kCFNull,
+    };
+  }
+  return TiRtcReactNativeSnapshotResult(result.code, snapshotMap);
+}
+
+NSDictionary* TiRtcReactNativeAudioMetricsResult(TiRtcAudioOutputMetricsResult* result) {
+  TiRtcAudioOutputMetricsSnapshot* snapshot = result.snapshot;
+  NSDictionary* snapshotMap = nil;
+  if (snapshot != nil) {
+    snapshotMap = @{
+      @"startup" : TiRtcReactNativeStartup(snapshot.startup),
+      @"stutter" : TiRtcReactNativeStutter(snapshot.stutter),
+      @"estimatedOutputLatencyMs" : @(snapshot.estimatedOutputLatencyMs),
+      @"audioCodec" : TiRtcReactNativeAudioCodec(snapshot.audioCodec),
+      @"audioSampleRateHz" : @(snapshot.audioSampleRateHz),
+      @"audioChannels" : @(snapshot.audioChannels),
+      @"audioInputBitrateKbps" : @(snapshot.audioInputBitrateKbps),
+      @"audioInputPacketRate" : @(snapshot.audioInputPacketRate),
+      @"audioRenderCallbackRate" : @(snapshot.audioRenderCallbackRate),
+      @"statsRefreshIntervalMs" : @(snapshot.statsRefreshIntervalMs),
+      @"statsUpdatedAtMonotonicMs" : @(snapshot.statsUpdatedAtMs),
+    };
+  }
+  return TiRtcReactNativeSnapshotResult(result.code, snapshotMap);
+}
+
+NSDictionary* TiRtcReactNativeVideoMetricsResult(TiRtcVideoOutputMetricsResult* result) {
+  TiRtcVideoOutputMetricsSnapshot* snapshot = result.snapshot;
+  NSDictionary* snapshotMap = nil;
+  if (snapshot != nil) {
+    snapshotMap = @{
+      @"startup" : TiRtcReactNativeStartup(snapshot.startup),
+      @"stutter" : TiRtcReactNativeStutter(snapshot.stutter),
+      @"estimatedOutputLatencyMs" : @(snapshot.estimatedOutputLatencyMs),
+      @"videoCodec" : TiRtcReactNativeVideoCodec(snapshot.videoCodec),
+      @"videoWidth" : @(snapshot.videoWidth),
+      @"videoHeight" : @(snapshot.videoHeight),
+      @"decoderBackend" : TiRtcReactNativeDecoderBackend(snapshot.decoderBackend),
+      @"videoInputBitrateKbps" : @(snapshot.videoInputBitrateKbps),
+      @"videoInputFps" : @(snapshot.videoInputFps),
+      @"videoDecodedFps" : @(snapshot.videoDecodedFps),
+      @"videoRenderFps" : @(snapshot.videoRenderFps),
+      @"statsRefreshIntervalMs" : @(snapshot.statsRefreshIntervalMs),
+      @"statsUpdatedAtMonotonicMs" : @(snapshot.statsUpdatedAtMs),
+    };
+  }
+  return TiRtcReactNativeSnapshotResult(result.code, snapshotMap);
+}
+
+NSDictionary* TiRtcReactNativeAudioDebugResult(TiRtcAudioOutputDebugSnapshotResult* result) {
+  TiRtcAudioOutputDebugSnapshot* snapshot = result.snapshot;
+  NSDictionary* snapshotMap = nil;
+  if (snapshot != nil) {
+    snapshotMap = @{
+      @"codec" : TiRtcReactNativeAudioCodec(snapshot.codec),
+      @"sampleRateHz" : @(snapshot.sampleRate),
+      @"channels" : @(snapshot.channels),
+    };
+  }
+  return TiRtcReactNativeSnapshotResult(result.code, snapshotMap);
+}
+
+NSDictionary* TiRtcReactNativeVideoDebugResult(TiRtcVideoOutputDebugSnapshotResult* result) {
+  TiRtcVideoOutputDebugSnapshot* snapshot = result.snapshot;
+  NSDictionary* snapshotMap = nil;
+  if (snapshot != nil) {
+    snapshotMap = @{
+      @"codec" : TiRtcReactNativeVideoCodec(snapshot.codec),
+      @"bitstreamFormat" : TiRtcReactNativeBitstreamFormat(snapshot.bitstreamFormat),
+      @"width" : @(snapshot.width),
+      @"height" : @(snapshot.height),
+      @"decoderPreference" : TiRtcReactNativeDecoderPreference(snapshot.decoderPreference),
+      @"resolvedDecoderBackend" : TiRtcReactNativeDecoderBackend(snapshot.resolvedDecoderBackend),
+    };
+  }
+  return TiRtcReactNativeSnapshotResult(result.code, snapshotMap);
+}
+
+NSDictionary* TiRtcReactNativeReleasedSnapshotResult(void) {
+  return TiRtcReactNativeSnapshotResult(TiRtcReactNativeErrorObjectReleased, nil);
+}
+
+NSArray<NSNumber*>* TiRtcReactNativeByteArray(NSData* data) {
+  NSMutableArray<NSNumber*>* bytes = [NSMutableArray arrayWithCapacity:data.length];
+  const uint8_t* buffer = (const uint8_t*)data.bytes;
+  for (NSUInteger index = 0; index < data.length; index++) {
+    [bytes addObject:@(buffer[index])];
+  }
+  return bytes;
+}
+
+NSData* TiRtcReactNativeDataFromArray(NSArray* array) {
+  NSMutableData* data = [NSMutableData dataWithCapacity:array.count];
+  for (id value in array) {
+    uint8_t byte = (uint8_t)[value integerValue];
+    [data appendBytes:&byte length:1];
+  }
+  return data;
+}

package/ios/TiRtcReactNativeNative.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+#if __has_include(<TiRTC/TiRTC-Swift.h>)
+#import <TiRTC/TiRTC-Swift.h>
+#else
+#import "TiRTC-Swift.h"
+#endif

package/ios/TiRtcReactNativeOptions.h

@@ -0,0 +1,11 @@
+#import "TiRtcSpec.h"
+#import "TiRtcReactNativeNative.h"
+
+TiRtcAudioOutputOptions* TiRtcReactNativeAudioOutputOptions(
+    JS::NativeTiRtc::NativeAudioOutputOptions& options);
+TiRtcVideoOutputOptions* TiRtcReactNativeVideoOutputOptions(
+    JS::NativeTiRtc::NativeVideoOutputOptions& options);
+TiRtcAudioInputOptions* TiRtcReactNativeAudioInputOptions(
+    JS::NativeTiRtc::NativeAudioInputOptions& options);
+TiRtcVideoInputOptions* TiRtcReactNativeVideoInputOptions(
+    JS::NativeTiRtc::NativeVideoInputOptions& options);