@byteplus/react-native-rtc 1.1.1 → 1.3.2

package/ios/live/VertcLive.m

@@ -6,16 +6,24 @@
 #import <TTSDKFramework/TTSDKFramework.h>
 #import <TTSDKFramework/VeLivePusherDef.h>
 #import "VeLivePushHelper.h"
+#import "VertcHelper.h"
 
-
+@interface VeLiveFpsTracker : NSObject
+- (void)start;
+- (void)stop;
+- (void)updateCaptureVieoWidth:(int)width height:(int)height;
+- (void)updatePreEncodeVieoWidth:(int)width height:(int)height;
+- (void)updateCaptureFrame:(NSInteger)frameCount;
+- (void)updatePreEncodeFrame:(NSInteger)frameCount;
+- (void)updateAfterRTCFrame:(NSInteger)frameCount;
+@end
 
 @interface VertcLive ()
-
 @property (nonatomic, strong) NSDictionary *options;
 @property (nonatomic, strong) ByteRTCVideo *rtcEngine;
 @property (nonatomic, strong) VeLivePusher *livePusher;
 @property (nonatomic, strong) id<VeLiveVideoFrameListener> videoFrameListener;
-
+@property (nonatomic, strong) VeLiveFpsTracker *fpsTracker;
 @end
 
 @implementation VertcLive
@@ -27,6 +35,8 @@
     self.livePusher = nil;
     self.rtcEngine = nil;
     self.options = nil;
+    [self.fpsTracker stop];
+    self.fpsTracker = nil;
 }
 
 - (int)startLiveVideoCapture:(ByteRTCVideo *)rtc viewId:(NSString *)viewId options:(NSDictionary *)options {
@@ -35,6 +45,11 @@
     if (pusher == nil) {
         @throw [NSException exceptionWithName:@"unknown videoEngine" reason:@"can't get pusher" userInfo:@{}];
     }
+//    if (self.fpsTracker != nil) {
+//        [self.fpsTracker stop];
+//    } else {
+//        self.fpsTracker = [[VeLiveFpsTracker alloc] init];
+//    }
     self.rtcEngine = rtc;
     self.options = options;
     self.livePusher = pusher;
@@ -42,21 +57,18 @@
     NSInteger streamIndexValue = [options[@"streamIndex"] integerValue] ?: 0;
     ByteRTCStreamIndex streamIndex = (streamIndexValue == 1) ? ByteRTCStreamIndexScreen : ByteRTCStreamIndexMain;
     [rtc setVideoSourceType:ByteRTCVideoSourceTypeExternal WithStreamIndex:streamIndex];
-
+    
+//    [self.fpsTracker start];
     int addRes = [self.livePusher addVideoFrameListener:self];
     NSLog(@"addVideoFrameListener result: %d", addRes);
-
     return 0;
 }
 
 - (int)stopLiveVideoCapture {
     if (self.rtcEngine == nil || self.livePusher == nil) {
+//        [self.fpsTracker stop];
         return 0;
     }
-    if (self.livePusher && self.videoFrameListener) {
-        [self.livePusher removeVideoFrameListener:self.videoFrameListener];
-        self.videoFrameListener = nil;
-    }
     NSInteger streamIndexValue = [self.options[@"streamIndex"] integerValue] ?: 0;
     ByteRTCStreamIndex streamIndex = (streamIndexValue == 1) ? ByteRTCStreamIndexScreen : ByteRTCStreamIndexMain;
     [self.rtcEngine setVideoSourceType:ByteRTCVideoSourceTypeInternal WithStreamIndex:streamIndex];
@@ -66,11 +78,12 @@
     self.options = nil;
     self.rtcEngine = nil;
     self.livePusher = nil;
+//    [self.fpsTracker stop];
     return 0;
 }
 
 - (VeLiveVideoFrameSource)getObservedVideoFrameSource {
-    return VeLiveVideoFrameSourcePreEncode;
+    return VeLiveVideoFrameSourceCapture | VeLiveVideoFrameSourcePreEncode;
 }
 
 - (ByteRTCVideoPixelFormat)convertToRtcPixelFormat:(VeLivePixelFormat)format {
@@ -85,11 +98,16 @@
     return ByteRTCVideoPixelFormatUnknown;
 }
 
+- (void)onCaptureVideoFrame:(VeLiveVideoFrame *)frame {
+    [self.fpsTracker updateCaptureFrame:1];
+    [self.fpsTracker updateCaptureVieoWidth:frame.width height:frame.height];
+}
+
 - (void)onPreEncodeVideoFrame:(VeLiveVideoFrame *)frame {
-    
+//    [self.fpsTracker updatePreEncodeFrame:1];
+//    [self.fpsTracker updatePreEncodeVieoWidth:frame.width height:frame.height];
     NSInteger streamIndexValue = [self.options[@"streamIndex"] integerValue] ?: 0;
     ByteRTCStreamIndex streamIndex = (streamIndexValue == 1) ? ByteRTCStreamIndexScreen : ByteRTCStreamIndexMain;
-    
     int res = 0;
     if (streamIndex == ByteRTCStreamIndexMain) {
         ByteRTCVideoPixelFormat pixelFormat = [self convertToRtcPixelFormat:frame.pixelFormat];
@@ -112,9 +130,12 @@
         }
         
         res = [self.rtcEngine pushExternalVideoFrame: videoFrame];
+        
+//        [self.fpsTracker updateAfterRTCFrame:1];
     }
     if (streamIndex == ByteRTCStreamIndexScreen) {
         res = [self.rtcEngine pushScreenVideoFrame:frame.pixelBuffer time:frame.pts rotation:frame.rotation];
+//        [self.fpsTracker updateAfterRTCFrame:1];
     }
     if (res != 0 && res != -202) {
         NSLog(@"bytertc push video frame fail return '%d'", res);
@@ -122,3 +143,134 @@
 }
 
 @end
+
+@protocol VeLiveTrackerProtocol <NSObject>
++ (void)sendPusherEventWith:(NSString *)eventKey api:(nullable NSString *)api value:(nullable id)value result:(nullable id)result;
+@end
+
+@interface VeLiveFpsTracker ()
+@property (nonatomic, strong) Class <VeLiveTrackerProtocol> trackerCls;
+@property (nonatomic, assign) NSTimeInterval lastTimestamp;
+@property (nonatomic, assign) NSInteger captureFrameCount;
+@property (nonatomic, assign) NSInteger preEncodeFrameCount;
+@property (nonatomic, assign) NSInteger afterRtcFrameCount;
+@property (nonatomic, strong) dispatch_queue_t queue;
+@property (nonatomic, copy) NSString *timerName;
+@property (nonatomic, assign) CGSize captureSize;
+@property (nonatomic, assign) CGSize preEncodeSize;
+@end
+
+@implementation VeLiveFpsTracker
+- (instancetype)init {
+    if (self = [super init]) {
+        _timerName = @"VeLiveFpsTracker";
+        _trackerCls = NSClassFromString(@"VeLiveTracker");
+        _queue = dispatch_queue_create("VeLiveFpsTracker-Queue", DISPATCH_QUEUE_SERIAL);
+    }
+    return self;
+}
+
+- (void)start {
+    [self clearFrameRecordAsync:NSDate.date.timeIntervalSince1970 * 1000];
+    __weak __typeof(self)weakSelf = self;
+    [[VertcHelper getInstance] schedualTimerWithIdentifier:self.timerName
+                                                  interval:2
+                                                     queue:self.queue
+                                                   repeats:YES
+                                                    action:^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        [self reportIfNeed];
+    }];
+}
+
+- (void)stop {
+    [[VertcHelper getInstance] cancelTimerWithName:_timerName];
+    [self clearFrameRecordAsync:0];
+}
+
+- (void)clearFrameRecordAsync:(NSTimeInterval)timestamp {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        [self clearFrameRecord:timestamp];
+    });
+}
+
+- (void)clearFrameRecord:(NSTimeInterval)timestamp {
+    self.lastTimestamp = timestamp;
+    self.captureFrameCount = 0;
+    self.preEncodeFrameCount = 0;
+    self.afterRtcFrameCount = 0;
+    self.captureSize = CGSizeZero;
+    self.preEncodeSize = CGSizeZero;
+}
+
+- (void)updateCaptureFrame:(NSInteger)frameCount {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        self.captureFrameCount += frameCount;
+    });
+}
+
+- (void)updatePreEncodeFrame:(NSInteger)frameCount {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        self.preEncodeFrameCount += frameCount;
+    });
+}
+
+- (void)updateAfterRTCFrame:(NSInteger)frameCount {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        self.afterRtcFrameCount += frameCount;
+    });
+}
+
+- (void)updateCaptureVieoWidth:(int)width height:(int)height {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        self.captureSize = CGSizeMake((CGFloat)width, (CGFloat)height);
+    });
+}
+
+- (void)updatePreEncodeVieoWidth:(int)width height:(int)height {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        self.preEncodeSize = CGSizeMake((CGFloat)width, (CGFloat)height);
+    });
+}
+
+- (void)reportIfNeed {
+    NSTimeInterval currentTime = NSDate.date.timeIntervalSince1970 * 1000;
+    NSTimeInterval duration = MAX(1, currentTime - self.lastTimestamp);
+    
+    int captureFps = (int)((self.captureFrameCount * 1000.0) / duration);
+    int preEncodeFps = (int)((self.preEncodeFrameCount * 1000.0) / duration);
+    int afterRtcFps = (int)((self.afterRtcFrameCount * 1000.0) / duration);
+    
+    [self reportEvent:@"livcore_statistics_fps" value:@{
+        @"captureFps" : @(captureFps),
+        @"preEncodeFps" : @(preEncodeFps),
+        @"afterRtcFps" : @(afterRtcFps),
+        @"captureSize" : NSStringFromCGSize(self.captureSize),
+        @"preEncodeSize" : NSStringFromCGSize(self.preEncodeSize),
+    }];
+    [self clearFrameRecord:currentTime];
+}
+
+- (void)reportEvent:(NSString *)key value:(NSDictionary *)value {
+    if (self.trackerCls != nil
+        && [self.trackerCls respondsToSelector:@selector(sendPusherEventWith:api:value:result:)]) {
+        [self.trackerCls sendPusherEventWith:key api:@"" value:value result:@""];
+    }
+#if DEBUG
+    NSLog(@"report: %@ %@", key, value);
+#endif
+}
+
+@end

package/ios/new_arch_core/RCTVertc.h

@@ -0,0 +1,23 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+//
+//  VertcModule.h
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import "VolcApiEngine/Engine.h"
+#import "VolcApiEngine/VolcEventObserver.h"
+#import "VertcImpl.h"
+#import "VertcSpec/VertcSpec.h"
+
+
+@interface RCTVertc : RCTEventEmitter <RCTBridgeModule, EventObserver, NativeVertcSpec>
+
+@property(nonatomic, strong) VertcImpl* impl;
+
++ (instancetype)shareInstance;
+
+@end

package/ios/new_arch_core/RCTVertc.mm

@@ -0,0 +1,89 @@
+//
+//  VertcModule.m
+//
+
+#import <UIKit/UIKit.h>
+#import <Foundation/Foundation.h>
+#import "VolcApiEngine/VolcEventObserver.h"
+#import <React/RCTEventEmitter.h>
+#import "VolcApiEngine/VolcEventObserver.h"
+#import "VertcApiEngine.h"
+#import "RTCHeader.h"
+#import "RCTVertc.h"
+#import "VertcImpl.h"
+#import <VertcSpec/VertcSpec.h>
+
+#define EVENT_NAME @"VertcModule:onEvent"
+
+@interface RCTVertc () <NativeVertcSpec>
+
+@end
+
+static RCTVertc *instance = nil;
+
+@implementation RCTVertc  {
+  bool hasListeners;
+}
+
++ (instancetype)shareInstance {
+  return instance;
+}
+
+//@See https://stackoverflow.com/questions/50773748/difference-requiresmainqueuesetup-and-dispatch-get-main-queue
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+- (dispatch_queue_t)methodQueue {
+  return dispatch_get_main_queue();
+}
+
+- (instancetype) init {
+  self = [super init];
+  if (self) {
+    instance = self;
+     self.impl = [[VertcImpl alloc] initWithModule: instance];
+  }
+  return self;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+  return @[ EVENT_NAME ];
+}
+
+- (void)onEvent:(NSString *)eventName data:(id)eventData {
+  NSDictionary *dic = @{@"event" : eventName, @"data" : eventData};
+  [self sendEventWithName:EVENT_NAME body:dic];
+}
+
+RCT_EXPORT_MODULE(Vertc)
+
+- (NSNumber *)newApiEngine {
+  return [self.impl newApiEngine];
+}
+
+- (void)call:(NSString *)params 
+    callback: (RCTResponseSenderBlock)callback {
+  NSDictionary * args = @{@"params": params};
+  [self.impl callApi:args callback:^(id _Nonnull res) {
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:res options:0 error:nil];
+    NSString* jsonResult = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
+    callback(@[jsonResult]);
+  }];
+}
+
+- (NSString *)callSync: (NSString *) params {
+  NSDictionary* args = @{@"params": params};  
+  NSDictionary* result = [self.impl callApiSync: args];
+  NSData *jsonData = [NSJSONSerialization dataWithJSONObject:result options:0 error:nil];
+  NSString* jsonResult = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
+  return jsonResult;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+ {
+    return std::make_shared<facebook::react::NativeVertcSpecJSI>(params);
+ }
+
+@end

package/ios/new_arch_core/VertcImpl.h

@@ -0,0 +1,33 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+//
+//  VertcImpl.h
+//  Pods
+//
+//  Created by ByteDance on 2025/10/28.
+//
+#import <Foundation/Foundation.h>
+#import "VolcApiEngine/Engine.h"
+#import "VolcApiEngine/VolcEventObserver.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface VertcImpl : NSObject
+
+@property(nonatomic, strong) VolcApiEngine *volcApiEngine;
+
+@property(nonatomic, weak) NSObject<EventObserver>* module;
+
+- (NSDictionary *) callApiSync: (nonnull NSDictionary*) args;
+
+- (void)callApi: (nonnull NSDictionary*) args
+       callback: (void (^)(id))callback;
+
+- (instancetype) initWithModule:(NSObject<EventObserver> *)module;
+
+- (id)newApiEngine;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/new_arch_core/VertcImpl.m

@@ -0,0 +1,53 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+//
+//  VertcImpl.m
+//  react-native-rtc
+//
+//  Created by ByteDance on 2025/10/28.
+//
+
+#import "VertcImpl.h"
+#import "VertcApiEngine.h"
+#import "VolcApiEngine/VolcEventObserver.h"
+#import <React/RCTBridgeModule.h>
+
+@interface VertcImpl()
+
+@end
+
+
+@implementation VertcImpl
+
+- (instancetype) initWithModule:(NSObject<EventObserver> *)module {
+  self = [super init];
+  if (self) {
+    self.module = module;
+  }
+  return self;
+}
+
+- (id)newApiEngine {
+  if (self.volcApiEngine == nil) {
+      self.volcApiEngine = [[VolcApiEngine alloc] init];
+      [self.volcApiEngine setObserver:self.module];
+      [VertcApiEngine.sharedInstance setApiEngine:[self volcApiEngine]];
+  }
+  return nil;
+}
+
+- (NSDictionary *)callApiSync:(NSDictionary *)args {
+  [self newApiEngine];
+  return [self.volcApiEngine callApi:args];
+}
+
+- (void)callApi:(NSDictionary *)args callback:(void (^)(id))callback {
+  [self newApiEngine];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    id _val = [self.volcApiEngine callApi:args];
+    callback(@[_val]);
+  });
+}
+
+@end

package/ios/new_arch_core/VertcViewManager.m

@@ -0,0 +1,51 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+//
+//  VeUIView.m
+//  rn
+//
+//  Created by ByteDance on 2024/3/27.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTViewManager.h>
+#import "VolcApiEngine/VolcViewManager.h"
+#import "VertcView.h"
+
+@interface VertcViewManager : RCTViewManager
+
+@end
+
+@implementation VertcViewManager
+
+RCT_EXPORT_MODULE(VertcView)
+
+RCT_EXPORT_VIEW_PROPERTY(onViewLoad, RCTBubblingEventBlock)
+
+RCT_CUSTOM_VIEW_PROPERTY(viewId, NSString, VertcView)
+{
+  if (json == nil) {
+    return;
+  }
+  
+  NSString * viewId = [RCTConvert NSString:json];
+  [view setViewId:viewId];
+  [VolcViewManager registerView:viewId view:view];
+  NSLog(@"[View] register view success viewId=%@", viewId);
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(kind, NSString, VertcView)
+{
+  if (json == nil) {
+    return;
+  }
+}
+
+- (VertcView *)view
+{
+  VertcView *view = [[VertcView alloc] init];
+  return view;
+}
+
+@end