@byteplus/react-native-rtc 1.0.6 → 1.0.7-rc.0

package/android/build.gradle

@@ -9,6 +9,8 @@ buildscript {
   }
 }
 
+def enableUnionForRTCWithLive = rootProject.ext.has('enableUnionForRTCWithLive') ? rootProject.ext.get('enableUnionForRTCWithLive') : false
+
 def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
@@ -51,7 +53,7 @@ def getNativeDep() {
   def parsedJson = new groovy.json.JsonSlurper().parseText(packageJson.text)
   def isBp = parsedJson.name.startsWith("@byteplus")
 
-  def enableUnionForRTCWithLive = rootProject.ext.has('enableUnionForRTCWithLive') ? rootProject.ext.get('enableUnionForRTCWithLive') : false
+  
   def rtcVersionToUse
   if (isBp) {
     rtcVersionToUse = enableUnionForRTCWithLive ? "3.58.1.20600" : "3.58.1.15100"
@@ -106,6 +108,7 @@ dependencies {
   implementation "com.facebook.react:react-native:+"
 
   implementation "com.volcengine:VolcApiEngine:1.6.2"
+  implementation project(':byteplus_react-native-live-push')
 //   implementation project(":hybrid-runtime");
 
   // Use the RTC SDK dependency determined by getNativeDep() which can be overridden by customer's app build.gradle.
@@ -118,4 +121,8 @@ dependencies {
   // byteplus       com.bytedanceapi:ttsdk-player_premium:1.42.300.101  com.bytedanceapi:ttsdk-player_standard:1.42.300.101
   def license_type = getLicenseType()
   implementation "com.bytedanceapi:ttsdk-player_$license_type:1.+"
+
+  if (enableUnionForRTCWithLive) {
+    api 'com.bytedanceapi:ttsdk-ttlivepush_rtc:1.46.300.2'
+  }
 }

package/android/src/main/java/com/volcengine/reactnative/vertc/VertcHelper.java

@@ -8,9 +8,12 @@ import android.util.Log;
 import com.ss.bytertc.engine.RTCVideo;
 import com.ss.bytertc.engine.VideoEncoderConfig;
 import com.ss.bytertc.engine.data.MirrorType;
+import com.ss.bytertc.engine.live.IPushSingleStreamToCDNObserver;
+import com.ss.bytertc.engine.live.PushSingleStreamParam;
 
 public class VertcHelper {
 
+  final public String TAG = "VertcHelper";
   static public VertcHelper sInstance = new VertcHelper();
 
   public static VertcHelper getInstance() {
@@ -24,4 +27,11 @@ public class VertcHelper {
   public int invokeSetLocalVideoMirrorType(RTCVideo engine, int mirrorType) {
     return engine.setLocalVideoMirrorType(MirrorType.fromId(mirrorType));
   }
+  
+  public int invokeStartPushSingleStreamToCDN(RTCVideo engine, String taskId, PushSingleStreamParam param) {
+    IPushSingleStreamToCDNObserver observer = (eventType, taskId1, error) -> {
+      Log.d(TAG, "StartPushSingleStreamToCDN: " + eventType + " " + taskId1 + " " + error);
+    };
+    return engine.startPushSingleStreamToCDN(taskId, param, observer);
+  }
 }

package/android/src/main/java/com/volcengine/reactnative/vertc/VertcModule.java

@@ -3,6 +3,8 @@
 
 package com.volcengine.reactnative.vertc;
 
+import android.util.Log;
+
 import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.Arguments;

package/android/src/main/java/com/volcengine/reactnative/vertc/VertcView.java

@@ -31,6 +31,6 @@ public class VertcView extends FrameLayout {
     ReactContext reactContext = (ReactContext)getContext();
     reactContext
       .getJSModule(RCTEventEmitter.class)
-      .receiveEvent(getId(), "load", event);
+      .receiveEvent(getId(), "vertcLoad", event);
   }
 }

package/android/src/main/java/com/volcengine/reactnative/vertc/VertcViewManager.java

@@ -72,7 +72,7 @@ public class VertcViewManager extends SimpleViewManager<VertcView> implements Vo
 
   public Map getExportedCustomBubblingEventTypeConstants() {
     return MapBuilder.builder().put(
-      "load",
+      "vertcLoad",
       MapBuilder.of(
         "phasedRegistrationNames",
         MapBuilder.of("bubbled", "onViewLoad")

package/android/src/main/java/com/volcengine/reactnative/vertc/live/VertcLive.java

@@ -0,0 +1,143 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package com.volcengine.reactnative.vertc.live;
+
+import android.util.Log;
+
+import com.ss.avframework.live.VeLivePusherDef;
+import com.ss.avframework.live.VeLiveVideoFrame;
+import com.ss.avframework.opengl.RendererCommon;
+import com.ss.bytertc.engine.RTCVideo;
+import com.ss.avframework.live.VeLivePusher;
+import com.ss.bytertc.engine.data.ReturnStatus;
+import com.ss.bytertc.engine.data.StreamIndex;
+import com.ss.bytertc.engine.data.VideoPixelFormat;
+import com.ss.bytertc.engine.data.VideoRotation;
+import com.ss.bytertc.engine.data.VideoSourceType;
+import java.util.concurrent.TimeUnit;
+import com.ss.bytertc.engine.video.builder.GLTextureVideoFrameBuilder;
+import com.volcengine.velive.rn.push.VeLivePushHelper;
+
+import javax.annotation.Nonnull;
+
+public class VertcLive {
+  private String TAG = "VertcLive";
+
+  private VeLivePusher mLivePusher;
+  private VeLivePusherDef.VeLiveVideoFrameListener mListener;
+  private org.json.JSONObject mOptions;
+  private RTCVideo mEngine;
+
+  /**
+   * @brief Start to capture live stream.
+   */
+  public int startLiveVideoCapture(RTCVideo engine, String pusherViewId, org.json.JSONObject options) {
+    try {
+      stopLiveVideoCapture();
+
+      mEngine = engine;
+      mOptions = options;
+
+      mLivePusher = getVeLivePusher(pusherViewId);
+      if (mLivePusher == null) {
+        throw new RuntimeException("[Unknown LivePusher] can't find pusher instance by view id.");
+      }
+      
+      // set video source as external
+      engine.setVideoSourceType(getStreamIndex(), VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL);
+      // set video frame listener
+      mListener = new VeLivePusherDef.VeLiveVideoFrameListener() {
+        @Nonnull
+        @Override
+        public VeLivePusherDef.VeLiveVideoFrameSource getObservedVideoFrameSource() {
+          return new VeLivePusherDef.VeLiveVideoFrameSource(VeLivePusherDef.VeLiveVideoFrameSource.VeLiveVideoFrameSourcePreEncode);
+        }
+
+        @Override
+        public void onPreEncodeVideoFrame(VeLiveVideoFrame frame) {
+          int ret_status = -1;
+          StreamIndex streamIndex = getStreamIndex();
+
+          float[] mMVPMatrix = RendererCommon.convertMatrixFromAndroidGraphicsMatrix(frame.getTextureMatrix());
+          GLTextureVideoFrameBuilder builder = new GLTextureVideoFrameBuilder(
+            frame.isOesTextureFrame() ? VideoPixelFormat.TEXTURE_OES : VideoPixelFormat.TEXTURE_2D
+          )
+            .setTextureID(frame.getTextureId())
+            .setWidth(frame.getWidth())
+            .setHeight(frame.getHeight())
+            .setRotation(VideoRotation.VIDEO_ROTATION_0)
+            .setTextureMatrix(mMVPMatrix)
+            .setEGLContext(VeLivePusher.getEGLContext())
+            .setTimeStampUs(System.currentTimeMillis() * TimeUnit.MILLISECONDS.toNanos(1));
+          
+          if (streamIndex == StreamIndex.STREAM_INDEX_MAIN) {
+            ret_status = engine.pushExternalVideoFrame(builder.build());
+          }
+          if (streamIndex == StreamIndex.STREAM_INDEX_SCREEN) {
+            ret_status = engine.pushScreenVideoFrame(builder.build());
+          }
+          boolean result = ret_status == ReturnStatus.RETURN_STATUS_SUCCESS.value()
+            || ret_status == ReturnStatus.RETURN_STATUS_VIDEO_TIMESTAMP_WARNING.value();
+          if (!result) {
+            Log.d(TAG, "Push external frame fail: " + ret_status);
+          }
+        }
+      };
+      mLivePusher.addVideoFrameListener(mListener);
+      
+      return 0;
+    } catch (Exception err) {
+      Log.d(TAG, "startLiveVideoCapture failed:" + err.getMessage());
+      throw new RuntimeException(err);
+    }
+  }
+
+  /**
+   * @brief Stop to capture live stream.
+   */
+  public int stopLiveVideoCapture() {
+    try {
+      if (
+        mOptions == null ||
+        mEngine == null
+      ) {
+        return 0;
+      }
+
+      // reset sourceType to Internal
+      mEngine.setVideoSourceType(getStreamIndex(), VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL);
+
+      // release listener
+      mLivePusher.removeVideoFrameListener(mListener);
+      mListener = null;
+      mOptions = null;
+      mLivePusher = null;
+      mEngine = null;
+
+      return 0;
+    } catch (Exception err) {
+      Log.d(TAG, "stopLiveVideoCapture failed:" + err.getMessage());
+      throw new RuntimeException(err);
+    }
+  }
+
+  
+  // Get VeLivePusher from Object
+  private VeLivePusher getVeLivePusher(String pusherViewId) {
+    
+    if (VeLivePushHelper.getPusher(pusherViewId) != null) {
+      return VeLivePushHelper.getPusher(pusherViewId);
+    }
+    
+    return null;
+  }
+  
+  // Get StreamIndex from options
+  private StreamIndex getStreamIndex() {
+    Number index = mOptions.optInt("streamIndex", StreamIndex.STREAM_INDEX_MAIN.value());
+    StreamIndex streamIndex = StreamIndex.fromId(index.intValue());
+    Log.d(TAG, "getStreamIndex:" + streamIndex);
+    return streamIndex;
+  }
+}

package/android/src/main/java/com/volcengine/reactnative/vertc/vod/VertcVod.java

@@ -136,11 +136,6 @@ public class VertcVod {
     if (arg instanceof TTVideoEngine) {
       return (TTVideoEngine)arg;
     }
-
-    Object decoded = VolcApiEnginePool.getInstance().decodeArg(arg, null);
-    if (decoded instanceof TTVideoEngine) {
-      return (TTVideoEngine)arg;
-    }
     
     return null;
   }

package/ios/VertcHelper.h

@@ -0,0 +1,21 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+//
+//  Pods
+//
+
+#import "RTCHeader.h"
+
+
+@interface VertcHelper : NSObject
+
++ (instancetype) getInstance;
+
+- (void)onStreamPushEvent:(ByteRTCSingleStreamPushEvent)event
+                   taskId:(NSString *_Nonnull)taskID
+                    error:(NSInteger)errorCode;
+
+- (int) invokeStartPushSingleStreamToCDN:(ByteRTCVideo *)rtc taskId:(NSString *_Nonnull)taskID singleStream:(ByteRTCPushSingleStreamParam *_Nonnull)singleStream;
+
+@end

package/ios/VertcHelper.m

@@ -0,0 +1,39 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+//
+//  react-native-rtc
+//
+
+#import <Foundation/Foundation.h>
+#import "RTCHeader.h"
+#import <TTSDKFramework/TTSDKFramework.h>
+#import <VertcHelper.h>
+
+
+#pragma mark - Helper
+@implementation VertcHelper
+
++ (instancetype) getInstance {
+    static VertcHelper *instance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [[VertcHelper alloc] init];
+    });
+    return instance;
+}
+
+- (void)onStreamPushEvent:(ByteRTCSingleStreamPushEvent)event
+                   taskId:(NSString *_Nonnull)taskID
+                    error:(NSInteger)errorCode {
+    NSLog(@"startPushSingleStreamToCDN: event=%ld, taskID=%@, error=%ld", (long)event, taskID, (long)errorCode);
+}
+
+- (int)invokeStartPushSingleStreamToCDN:(ByteRTCVideo *)rtc taskId:(NSString *_Nonnull)taskID singleStream:(ByteRTCPushSingleStreamParam *_Nonnull)singleStream {
+    singleStream.pushType = ByteRTCSingleStreamPushToCDN;
+    singleStream.isScreen = singleStream.isScreen || false;
+    int res = [rtc startPushSingleStreamToCDN:taskID singleStream:singleStream observer:self];
+    return res;
+}
+
+@end

package/ios/live/VertcLive.h

@@ -0,0 +1,24 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+//
+//  VertcLive.h
+// 
+
+#import <Foundation/Foundation.h>
+#import "RTCHeader.h"
+#import <TTSDKFramework/TTSDKFramework.h>
+
+@interface VertcLive : NSObject
+
+- (int) startLiveVideoCapture:(ByteRTCVideo *)rtc viewId:(NSString *)viewId options:(NSDictionary *)options;
+
+- (int) stopLiveVideoCapture;
+
+- (VeLiveVideoFrameSource)getObservedVideoFrameSource;
+
+- (ByteRTCVideoPixelFormat)convertToRtcPixelFormat:(VeLivePixelFormat)format;
+
+- (void)onPreEncodeVideoFrame:(VeLiveVideoFrame *)frame;
+
+@end

package/ios/live/VertcLive.m

@@ -0,0 +1,124 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+#import "VertcLive.h"
+#import "RTCHeader.h"
+#import <TTSDKFramework/TTSDKFramework.h>
+#import <TTSDKFramework/VeLivePusherDef.h>
+#import "VeLivePushHelper.h"
+
+
+
+@interface VertcLive ()
+
+@property (nonatomic, strong) NSDictionary *options;
+@property (nonatomic, strong) ByteRTCVideo *rtcEngine;
+@property (nonatomic, strong) VeLivePusher *livePusher;
+@property (nonatomic, strong) id<VeLiveVideoFrameListener> videoFrameListener;
+
+@end
+
+@implementation VertcLive
+
+- (void)dealloc {
+    if (self.livePusher && self.videoFrameListener) {
+        [self.livePusher removeVideoFrameListener:self.videoFrameListener];
+    }
+    self.livePusher = nil;
+    self.rtcEngine = nil;
+    self.options = nil;
+}
+
+- (int)startLiveVideoCapture:(ByteRTCVideo *)rtc viewId:(NSString *)viewId options:(NSDictionary *)options {
+    
+    VeLivePusher *pusher = [VeLivePushHelper getPusher:viewId];
+    if (pusher == nil) {
+        @throw [NSException exceptionWithName:@"unknown videoEngine" reason:@"can't get pusher" userInfo:@{}];
+    }
+    self.rtcEngine = rtc;
+    self.options = options;
+    self.livePusher = pusher;
+
+    NSInteger streamIndexValue = [options[@"streamIndex"] integerValue] ?: 0;
+    ByteRTCStreamIndex streamIndex = (streamIndexValue == 1) ? ByteRTCStreamIndexScreen : ByteRTCStreamIndexMain;
+    [rtc setVideoSourceType:ByteRTCVideoSourceTypeExternal WithStreamIndex:streamIndex];
+
+    int addRes = [self.livePusher addVideoFrameListener:self];
+    NSLog(@"addVideoFrameListener result: %d", addRes);
+
+    return 0;
+}
+
+- (int)stopLiveVideoCapture {
+    if (self.rtcEngine == nil || self.livePusher == nil) {
+        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];
+    
+    [self.livePusher removeVideoFrameListener:self];
+
+    self.options = nil;
+    self.rtcEngine = nil;
+    self.livePusher = nil;
+    return 0;
+}
+
+- (VeLiveVideoFrameSource)getObservedVideoFrameSource {
+    return VeLiveVideoFrameSourcePreEncode;
+}
+
+- (ByteRTCVideoPixelFormat)convertToRtcPixelFormat:(VeLivePixelFormat)format {
+    switch (format) {
+        case VeLivePixelFormatBGRA32: return ByteRTCVideoPixelFormatBGRA;
+        case VeLivePixelFormatNV12: return ByteRTCVideoPixelFormatNV12;
+        case VeLivePixelFormatNV21: return ByteRTCVideoPixelFormatNV21;
+        case VeLivePixelFormatI420: return ByteRTCVideoPixelFormatI420;
+        case VeLivePixelFormat2DTexture: return ByteRTCVideoPixelFormatGLTexture2D;
+        case VeLiveVideoBufferTypeUnKnown: return ByteRTCVideoPixelFormatUnknown;
+    }
+    return ByteRTCVideoPixelFormatUnknown;
+}
+
+- (void)onPreEncodeVideoFrame:(VeLiveVideoFrame *)frame {
+    
+    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];
+        ByteRTCVideoFrame *videoFrame = [[ByteRTCVideoFrame alloc] init];
+        videoFrame.width = frame.width;
+        videoFrame.height = frame.height;
+        videoFrame.format = (int)pixelFormat;
+        videoFrame.time = frame.pts;
+        // videoFrame.contentType = ByteRTCVideoContentTypeNormalFrame;
+        // same enum
+        videoFrame.rotation = (ByteRTCVideoRotation)frame.rotation;
+        
+        if (frame.sampleBuffer) {
+            videoFrame.textureBuf = CMSampleBufferGetImageBuffer(frame.sampleBuffer);
+            videoFrame.time = CMSampleBufferGetPresentationTimeStamp(frame.sampleBuffer);
+        }
+        
+        if (frame.pixelBuffer) {
+            videoFrame.textureBuf = frame.pixelBuffer;
+        }
+        
+        res = [self.rtcEngine pushExternalVideoFrame: videoFrame];
+    }
+    if (streamIndex == ByteRTCStreamIndexScreen) {
+        res = [self.rtcEngine pushScreenVideoFrame:frame.pixelBuffer time:frame.pts rotation:frame.rotation];
+    }
+    if (res != 0 && res != -202) {
+        NSLog(@"bytertc push video frame fail return '%d'", res);
+    }
+}
+
+@end

package/lib/commonjs/index.js

@@ -68201,7 +68201,83 @@ var VertcVod = function () {
     return _classThis;
 }();
 
-var VertcHelper = function () {
+var VertcLive$1 = function () {
+    var _classDecorators = [NativeClass('com.volcengine.reactnative.vertc.live.VertcLive')];
+    var _classDescriptor;
+    var _classExtraInitializers = [];
+    var _classThis;
+    var _instanceExtraInitializers = [];
+    var _startLiveVideoCapture_decorators;
+    var _stopLiveVideoCapture_decorators;
+    _classThis = /** @class */ (function () {
+        function VertcLive_1() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        VertcLive_1.prototype.startLiveVideoCapture = function (video, viewId, options) {
+            throw new Error('not implement');
+        };
+        VertcLive_1.prototype.stopLiveVideoCapture = function () {
+            throw new Error('not implement');
+        };
+        return VertcLive_1;
+    }());
+    __setFunctionName(_classThis, "VertcLive");
+    (function () {
+        var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _startLiveVideoCapture_decorators = [NativeMethod()];
+        _stopLiveVideoCapture_decorators = [NativeMethod()];
+        __esDecorate(_classThis, null, _startLiveVideoCapture_decorators, { kind: "method", name: "startLiveVideoCapture", static: false, private: false, access: { has: function (obj) { return "startLiveVideoCapture" in obj; }, get: function (obj) { return obj.startLiveVideoCapture; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _stopLiveVideoCapture_decorators, { kind: "method", name: "stopLiveVideoCapture", static: false, private: false, access: { has: function (obj) { return "stopLiveVideoCapture" in obj; }, get: function (obj) { return obj.stopLiveVideoCapture; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return _classThis;
+}();
+
+var VertcLive = function () {
+    var _classDecorators = [NativeClass('VertcLive')];
+    var _classDescriptor;
+    var _classExtraInitializers = [];
+    var _classThis;
+    var _instanceExtraInitializers = [];
+    var _init_decorators;
+    var _startLiveVideoCapture_decorators;
+    var _stopLiveVideoCapture_decorators;
+    _classThis = /** @class */ (function () {
+        function VertcLive_1() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        VertcLive_1.prototype.init = function () {
+            throw new Error('not implement');
+        };
+        VertcLive_1.prototype.startLiveVideoCapture = function (video, viewId, options) {
+            throw new Error('not implement');
+        };
+        VertcLive_1.prototype.stopLiveVideoCapture = function () {
+            throw new Error('not implement');
+        };
+        return VertcLive_1;
+    }());
+    __setFunctionName(_classThis, "VertcLive");
+    (function () {
+        var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _init_decorators = [NativeMethodSync('init')];
+        _startLiveVideoCapture_decorators = [NativeMethod('startLiveVideoCapture:viewId:options:')];
+        _stopLiveVideoCapture_decorators = [NativeMethod('stopLiveVideoCapture')];
+        __esDecorate(_classThis, null, _init_decorators, { kind: "method", name: "init", static: false, private: false, access: { has: function (obj) { return "init" in obj; }, get: function (obj) { return obj.init; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _startLiveVideoCapture_decorators, { kind: "method", name: "startLiveVideoCapture", static: false, private: false, access: { has: function (obj) { return "startLiveVideoCapture" in obj; }, get: function (obj) { return obj.startLiveVideoCapture; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _stopLiveVideoCapture_decorators, { kind: "method", name: "stopLiveVideoCapture", static: false, private: false, access: { has: function (obj) { return "stopLiveVideoCapture" in obj; }, get: function (obj) { return obj.stopLiveVideoCapture; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return _classThis;
+}();
+
+var VertcHelper$1 = function () {
     var _classDecorators = [NativeClass('com.volcengine.reactnative.vertc.VertcHelper')];
     var _classDescriptor;
     var _classExtraInitializers = [];
@@ -68212,6 +68288,7 @@ var VertcHelper = function () {
     var _static_getInstance_decorators;
     var _invokeSetVideoEncoderConfig_decorators;
     var _invokeSetLocalVideoMirrorType_decorators;
+    var _invokeStartPushSingleStreamToCDN_decorators;
     var VertcHelper = _classThis = /** @class */ (function (_super) {
         __extends(VertcHelper_1, _super);
         function VertcHelper_1() {
@@ -68228,6 +68305,9 @@ var VertcHelper = function () {
         VertcHelper_1.prototype.invokeSetLocalVideoMirrorType = function (video, mirrorType) {
             throw new Error('not implement');
         };
+        VertcHelper_1.prototype.invokeStartPushSingleStreamToCDN = function (video, taskId, param) {
+            throw new Error('not implement');
+        };
         return VertcHelper_1;
     }(_classSuper));
     __setFunctionName(_classThis, "VertcHelper");
@@ -68237,9 +68317,54 @@ var VertcHelper = function () {
         _static_getInstance_decorators = [ReturnClass(function () { return VertcHelper; }), NativeStaticMethodSync()];
         _invokeSetVideoEncoderConfig_decorators = [NativeMethod()];
         _invokeSetLocalVideoMirrorType_decorators = [NativeMethod()];
+        _invokeStartPushSingleStreamToCDN_decorators = [NativeMethod()];
         __esDecorate(_classThis, null, _static_getInstance_decorators, { kind: "method", name: "getInstance", static: true, private: false, access: { has: function (obj) { return "getInstance" in obj; }, get: function (obj) { return obj.getInstance; } }, metadata: _metadata }, null, _staticExtraInitializers);
         __esDecorate(_classThis, null, _invokeSetVideoEncoderConfig_decorators, { kind: "method", name: "invokeSetVideoEncoderConfig", static: false, private: false, access: { has: function (obj) { return "invokeSetVideoEncoderConfig" in obj; }, get: function (obj) { return obj.invokeSetVideoEncoderConfig; } }, metadata: _metadata }, null, _instanceExtraInitializers);
         __esDecorate(_classThis, null, _invokeSetLocalVideoMirrorType_decorators, { kind: "method", name: "invokeSetLocalVideoMirrorType", static: false, private: false, access: { has: function (obj) { return "invokeSetLocalVideoMirrorType" in obj; }, get: function (obj) { return obj.invokeSetLocalVideoMirrorType; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _invokeStartPushSingleStreamToCDN_decorators, { kind: "method", name: "invokeStartPushSingleStreamToCDN", static: false, private: false, access: { has: function (obj) { return "invokeStartPushSingleStreamToCDN" in obj; }, get: function (obj) { return obj.invokeStartPushSingleStreamToCDN; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        VertcHelper = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _staticExtraInitializers);
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return VertcHelper = _classThis;
+}();
+
+var VertcHelper = function () {
+    var _classDecorators = [NativeClass('VertcHelper')];
+    var _classDescriptor;
+    var _classExtraInitializers = [];
+    var _classThis;
+    var _staticExtraInitializers = [];
+    var _instanceExtraInitializers = [];
+    var _static_getInstance_decorators;
+    var _init_decorators;
+    var _invokeStartPushSingleStreamToCDN_decorators;
+    var VertcHelper = _classThis = /** @class */ (function () {
+        function VertcHelper_1() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        VertcHelper_1.prototype.init = function () {
+            throw new Error('not implement');
+        };
+        VertcHelper_1.getInstance = function () {
+            throw new Error('not implement');
+        };
+        VertcHelper_1.prototype.invokeStartPushSingleStreamToCDN = function (video, taskId, param) {
+            throw new Error('not implement');
+        };
+        return VertcHelper_1;
+    }());
+    __setFunctionName(_classThis, "VertcHelper");
+    (function () {
+        var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _init_decorators = [NativeMethodSync('init')];
+        _static_getInstance_decorators = [ReturnClass(function () { return VertcHelper; }), NativeStaticMethodSync('getInstance')];
+        _invokeStartPushSingleStreamToCDN_decorators = [NativeMethod('invokeStartPushSingleStreamToCDN:taskId:singleStream:')];
+        __esDecorate(_classThis, null, _static_getInstance_decorators, { kind: "method", name: "getInstance", static: true, private: false, access: { has: function (obj) { return "getInstance" in obj; }, get: function (obj) { return obj.getInstance; } }, metadata: _metadata }, null, _staticExtraInitializers);
+        __esDecorate(_classThis, null, _init_decorators, { kind: "method", name: "init", static: false, private: false, access: { has: function (obj) { return "init" in obj; }, get: function (obj) { return obj.init; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _invokeStartPushSingleStreamToCDN_decorators, { kind: "method", name: "invokeStartPushSingleStreamToCDN", static: false, private: false, access: { has: function (obj) { return "invokeStartPushSingleStreamToCDN" in obj; }, get: function (obj) { return obj.invokeStartPushSingleStreamToCDN; } }, metadata: _metadata }, null, _instanceExtraInitializers);
         __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
         VertcHelper = _classThis = _classDescriptor.value;
         if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -68307,15 +68432,17 @@ extendsClassMember(RemoteVideoStats, 'codecType')(function () {
 });
 extendsClassMethod(android_RTCRoomEventHandler, 'onStreamRemove', function () {
     return function impl(stream, reason) {
+        var _a, _b;
         if (this._instance.onStreamRemove) {
-            this._instance.onStreamRemove(packObject(stream, RTCStream), t_StreamRemoveReason.android_to_ts(reason));
+            (_b = (_a = this._instance).onStreamRemove) === null || _b === void 0 ? void 0 : _b.call(_a, packObject(stream, RTCStream), t_StreamRemoveReason.android_to_ts(reason));
         }
     };
 });
 extendsClassMethod(ios_RTCRoomEventHandler, 'rtcRoom$onStreamRemove$stream$reason', function () {
     return function impl(rtcRoom, uid, stream, reason) {
+        var _a, _b;
         if (this._instance.onStreamRemove) {
-            this._instance.onStreamRemove(packObject(stream, RTCStream), t_StreamRemoveReason.ios_to_ts(reason));
+            (_b = (_a = this._instance).onStreamRemove) === null || _b === void 0 ? void 0 : _b.call(_a, packObject(stream, RTCStream), t_StreamRemoveReason.ios_to_ts(reason));
         }
     };
 });
@@ -68483,11 +68610,52 @@ extendsClassMethod(RTCVideo, 'stopVodPlayerCapture', function () {
         }
     };
 });
+var LiveHelperKey = '_live';
+extendsClassMethod(RTCVideo, 'startLiveVideoCapture', function () {
+    return function impl(viewId, options) {
+        var _this = this;
+        if (options === void 0) { options = {}; }
+        if (!viewId) {
+            throw new Error('Live player view id is required.');
+        }
+        var a = function () {
+            var androidRtc = unpackObject(_this);
+            var ins = new VertcLive$1();
+            _this[LiveHelperKey] = ins;
+            return ins.startLiveVideoCapture(androidRtc, viewId, options);
+        };
+        var i = function () {
+            var iosRtc = unpackObject(_this);
+            var ins = new VertcLive();
+            _this[LiveHelperKey] = ins;
+            return ins.startLiveVideoCapture(iosRtc, viewId, options);
+        };
+        var $os = env.getOS();
+        if ($os === 'android') {
+            return a();
+        }
+        else if ($os === 'ios') {
+            return i();
+        }
+        else {
+            throw new Error('Not Support Platform ' + $os);
+        }
+    };
+});
+extendsClassMethod(RTCVideo, 'stopLiveVideoCapture', function () {
+    return function impl() {
+        var ins = this[LiveHelperKey];
+        if (!ins) {
+            return -2;
+        }
+        return ins.stopLiveVideoCapture();
+    };
+});
 extendsClassMethod(RTCVideo, 'setVideoEncoderConfig', function (origin) {
     return function impl(channelSolutions) {
         var _this = this;
         var a = function () {
-            var vertc = VertcHelper.getInstance();
+            var vertc = VertcHelper$1.getInstance();
             return vertc.invokeSetVideoEncoderConfig(unpackObject(_this), channelSolutions.map(function (item) { return unpackObject(item); }));
         };
         var i = function () {
@@ -68505,11 +68673,44 @@ extendsClassMethod(RTCVideo, 'setVideoEncoderConfig', function (origin) {
         }
     };
 });
+extendsClassMethod(RTCVideo, 'startPushSingleStreamToCDN', function () {
+    return function impl(taskId, params) {
+        var _this = this;
+        var a = function () {
+            var vertc = VertcHelper$1.getInstance();
+            var streamParams = new PushSingleStreamParam$1();
+            streamParams.roomId = params.roomId;
+            streamParams.userId = params.userId;
+            streamParams.url = params.url;
+            streamParams.isScreen = params.isScreen || false;
+            return vertc.invokeStartPushSingleStreamToCDN(unpackObject(_this), taskId, streamParams);
+        };
+        var i = function () {
+            var vertc = VertcHelper.getInstance();
+            var streamParams = new ByteRTCPushSingleStreamParam();
+            streamParams.roomId = params.roomId;
+            streamParams.userId = params.userId;
+            streamParams.url = params.url;
+            streamParams.isScreen = params.isScreen || false;
+            return vertc.invokeStartPushSingleStreamToCDN(unpackObject(_this), taskId, streamParams);
+        };
+        var $os = env.getOS();
+        if ($os === 'android') {
+            return a().then(Number);
+        }
+        else if ($os === 'ios') {
+            return i().then(Number);
+        }
+        else {
+            throw new Error('Not Support Platform ' + $os);
+        }
+    };
+});
 extendsClassMethod(RTCVideo, 'setLocalVideoMirrorType', function (origin) {
     return function impl(mirrorType) {
         var _this = this;
         var a = function () {
-            var vertc = VertcHelper.getInstance();
+            var vertc = VertcHelper$1.getInstance();
             return vertc.invokeSetLocalVideoMirrorType(unpackObject(_this), t_MirrorType.ts_to_android(mirrorType));
         };
         var i = function () {
@@ -69000,12 +69201,6 @@ var RTCManager = /** @class */ (function () {
         });
         return RTCVideo.setLogConfig(logConfig);
     };
-    /** {en}
-     * @brief Set vod-player instance
-     */
-    RTCManager.prototype.setVodPlayer = function (vodPlayer) {
-        this.vodPlayer = vodPlayer;
-    };
     return RTCManager;
 }());
 

package/lib/module/index.js

@@ -68199,7 +68199,83 @@ var VertcVod = function () {
     return _classThis;
 }();
 
-var VertcHelper = function () {
+var VertcLive$1 = function () {
+    var _classDecorators = [NativeClass('com.volcengine.reactnative.vertc.live.VertcLive')];
+    var _classDescriptor;
+    var _classExtraInitializers = [];
+    var _classThis;
+    var _instanceExtraInitializers = [];
+    var _startLiveVideoCapture_decorators;
+    var _stopLiveVideoCapture_decorators;
+    _classThis = /** @class */ (function () {
+        function VertcLive_1() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        VertcLive_1.prototype.startLiveVideoCapture = function (video, viewId, options) {
+            throw new Error('not implement');
+        };
+        VertcLive_1.prototype.stopLiveVideoCapture = function () {
+            throw new Error('not implement');
+        };
+        return VertcLive_1;
+    }());
+    __setFunctionName(_classThis, "VertcLive");
+    (function () {
+        var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _startLiveVideoCapture_decorators = [NativeMethod()];
+        _stopLiveVideoCapture_decorators = [NativeMethod()];
+        __esDecorate(_classThis, null, _startLiveVideoCapture_decorators, { kind: "method", name: "startLiveVideoCapture", static: false, private: false, access: { has: function (obj) { return "startLiveVideoCapture" in obj; }, get: function (obj) { return obj.startLiveVideoCapture; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _stopLiveVideoCapture_decorators, { kind: "method", name: "stopLiveVideoCapture", static: false, private: false, access: { has: function (obj) { return "stopLiveVideoCapture" in obj; }, get: function (obj) { return obj.stopLiveVideoCapture; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return _classThis;
+}();
+
+var VertcLive = function () {
+    var _classDecorators = [NativeClass('VertcLive')];
+    var _classDescriptor;
+    var _classExtraInitializers = [];
+    var _classThis;
+    var _instanceExtraInitializers = [];
+    var _init_decorators;
+    var _startLiveVideoCapture_decorators;
+    var _stopLiveVideoCapture_decorators;
+    _classThis = /** @class */ (function () {
+        function VertcLive_1() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        VertcLive_1.prototype.init = function () {
+            throw new Error('not implement');
+        };
+        VertcLive_1.prototype.startLiveVideoCapture = function (video, viewId, options) {
+            throw new Error('not implement');
+        };
+        VertcLive_1.prototype.stopLiveVideoCapture = function () {
+            throw new Error('not implement');
+        };
+        return VertcLive_1;
+    }());
+    __setFunctionName(_classThis, "VertcLive");
+    (function () {
+        var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _init_decorators = [NativeMethodSync('init')];
+        _startLiveVideoCapture_decorators = [NativeMethod('startLiveVideoCapture:viewId:options:')];
+        _stopLiveVideoCapture_decorators = [NativeMethod('stopLiveVideoCapture')];
+        __esDecorate(_classThis, null, _init_decorators, { kind: "method", name: "init", static: false, private: false, access: { has: function (obj) { return "init" in obj; }, get: function (obj) { return obj.init; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _startLiveVideoCapture_decorators, { kind: "method", name: "startLiveVideoCapture", static: false, private: false, access: { has: function (obj) { return "startLiveVideoCapture" in obj; }, get: function (obj) { return obj.startLiveVideoCapture; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _stopLiveVideoCapture_decorators, { kind: "method", name: "stopLiveVideoCapture", static: false, private: false, access: { has: function (obj) { return "stopLiveVideoCapture" in obj; }, get: function (obj) { return obj.stopLiveVideoCapture; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return _classThis;
+}();
+
+var VertcHelper$1 = function () {
     var _classDecorators = [NativeClass('com.volcengine.reactnative.vertc.VertcHelper')];
     var _classDescriptor;
     var _classExtraInitializers = [];
@@ -68210,6 +68286,7 @@ var VertcHelper = function () {
     var _static_getInstance_decorators;
     var _invokeSetVideoEncoderConfig_decorators;
     var _invokeSetLocalVideoMirrorType_decorators;
+    var _invokeStartPushSingleStreamToCDN_decorators;
     var VertcHelper = _classThis = /** @class */ (function (_super) {
         __extends(VertcHelper_1, _super);
         function VertcHelper_1() {
@@ -68226,6 +68303,9 @@ var VertcHelper = function () {
         VertcHelper_1.prototype.invokeSetLocalVideoMirrorType = function (video, mirrorType) {
             throw new Error('not implement');
         };
+        VertcHelper_1.prototype.invokeStartPushSingleStreamToCDN = function (video, taskId, param) {
+            throw new Error('not implement');
+        };
         return VertcHelper_1;
     }(_classSuper));
     __setFunctionName(_classThis, "VertcHelper");
@@ -68235,9 +68315,54 @@ var VertcHelper = function () {
         _static_getInstance_decorators = [ReturnClass(function () { return VertcHelper; }), NativeStaticMethodSync()];
         _invokeSetVideoEncoderConfig_decorators = [NativeMethod()];
         _invokeSetLocalVideoMirrorType_decorators = [NativeMethod()];
+        _invokeStartPushSingleStreamToCDN_decorators = [NativeMethod()];
         __esDecorate(_classThis, null, _static_getInstance_decorators, { kind: "method", name: "getInstance", static: true, private: false, access: { has: function (obj) { return "getInstance" in obj; }, get: function (obj) { return obj.getInstance; } }, metadata: _metadata }, null, _staticExtraInitializers);
         __esDecorate(_classThis, null, _invokeSetVideoEncoderConfig_decorators, { kind: "method", name: "invokeSetVideoEncoderConfig", static: false, private: false, access: { has: function (obj) { return "invokeSetVideoEncoderConfig" in obj; }, get: function (obj) { return obj.invokeSetVideoEncoderConfig; } }, metadata: _metadata }, null, _instanceExtraInitializers);
         __esDecorate(_classThis, null, _invokeSetLocalVideoMirrorType_decorators, { kind: "method", name: "invokeSetLocalVideoMirrorType", static: false, private: false, access: { has: function (obj) { return "invokeSetLocalVideoMirrorType" in obj; }, get: function (obj) { return obj.invokeSetLocalVideoMirrorType; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _invokeStartPushSingleStreamToCDN_decorators, { kind: "method", name: "invokeStartPushSingleStreamToCDN", static: false, private: false, access: { has: function (obj) { return "invokeStartPushSingleStreamToCDN" in obj; }, get: function (obj) { return obj.invokeStartPushSingleStreamToCDN; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        VertcHelper = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _staticExtraInitializers);
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return VertcHelper = _classThis;
+}();
+
+var VertcHelper = function () {
+    var _classDecorators = [NativeClass('VertcHelper')];
+    var _classDescriptor;
+    var _classExtraInitializers = [];
+    var _classThis;
+    var _staticExtraInitializers = [];
+    var _instanceExtraInitializers = [];
+    var _static_getInstance_decorators;
+    var _init_decorators;
+    var _invokeStartPushSingleStreamToCDN_decorators;
+    var VertcHelper = _classThis = /** @class */ (function () {
+        function VertcHelper_1() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        VertcHelper_1.prototype.init = function () {
+            throw new Error('not implement');
+        };
+        VertcHelper_1.getInstance = function () {
+            throw new Error('not implement');
+        };
+        VertcHelper_1.prototype.invokeStartPushSingleStreamToCDN = function (video, taskId, param) {
+            throw new Error('not implement');
+        };
+        return VertcHelper_1;
+    }());
+    __setFunctionName(_classThis, "VertcHelper");
+    (function () {
+        var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _init_decorators = [NativeMethodSync('init')];
+        _static_getInstance_decorators = [ReturnClass(function () { return VertcHelper; }), NativeStaticMethodSync('getInstance')];
+        _invokeStartPushSingleStreamToCDN_decorators = [NativeMethod('invokeStartPushSingleStreamToCDN:taskId:singleStream:')];
+        __esDecorate(_classThis, null, _static_getInstance_decorators, { kind: "method", name: "getInstance", static: true, private: false, access: { has: function (obj) { return "getInstance" in obj; }, get: function (obj) { return obj.getInstance; } }, metadata: _metadata }, null, _staticExtraInitializers);
+        __esDecorate(_classThis, null, _init_decorators, { kind: "method", name: "init", static: false, private: false, access: { has: function (obj) { return "init" in obj; }, get: function (obj) { return obj.init; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _invokeStartPushSingleStreamToCDN_decorators, { kind: "method", name: "invokeStartPushSingleStreamToCDN", static: false, private: false, access: { has: function (obj) { return "invokeStartPushSingleStreamToCDN" in obj; }, get: function (obj) { return obj.invokeStartPushSingleStreamToCDN; } }, metadata: _metadata }, null, _instanceExtraInitializers);
         __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
         VertcHelper = _classThis = _classDescriptor.value;
         if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -68305,15 +68430,17 @@ extendsClassMember(RemoteVideoStats, 'codecType')(function () {
 });
 extendsClassMethod(android_RTCRoomEventHandler, 'onStreamRemove', function () {
     return function impl(stream, reason) {
+        var _a, _b;
         if (this._instance.onStreamRemove) {
-            this._instance.onStreamRemove(packObject(stream, RTCStream), t_StreamRemoveReason.android_to_ts(reason));
+            (_b = (_a = this._instance).onStreamRemove) === null || _b === void 0 ? void 0 : _b.call(_a, packObject(stream, RTCStream), t_StreamRemoveReason.android_to_ts(reason));
         }
     };
 });
 extendsClassMethod(ios_RTCRoomEventHandler, 'rtcRoom$onStreamRemove$stream$reason', function () {
     return function impl(rtcRoom, uid, stream, reason) {
+        var _a, _b;
         if (this._instance.onStreamRemove) {
-            this._instance.onStreamRemove(packObject(stream, RTCStream), t_StreamRemoveReason.ios_to_ts(reason));
+            (_b = (_a = this._instance).onStreamRemove) === null || _b === void 0 ? void 0 : _b.call(_a, packObject(stream, RTCStream), t_StreamRemoveReason.ios_to_ts(reason));
         }
     };
 });
@@ -68481,11 +68608,52 @@ extendsClassMethod(RTCVideo, 'stopVodPlayerCapture', function () {
         }
     };
 });
+var LiveHelperKey = '_live';
+extendsClassMethod(RTCVideo, 'startLiveVideoCapture', function () {
+    return function impl(viewId, options) {
+        var _this = this;
+        if (options === void 0) { options = {}; }
+        if (!viewId) {
+            throw new Error('Live player view id is required.');
+        }
+        var a = function () {
+            var androidRtc = unpackObject(_this);
+            var ins = new VertcLive$1();
+            _this[LiveHelperKey] = ins;
+            return ins.startLiveVideoCapture(androidRtc, viewId, options);
+        };
+        var i = function () {
+            var iosRtc = unpackObject(_this);
+            var ins = new VertcLive();
+            _this[LiveHelperKey] = ins;
+            return ins.startLiveVideoCapture(iosRtc, viewId, options);
+        };
+        var $os = env.getOS();
+        if ($os === 'android') {
+            return a();
+        }
+        else if ($os === 'ios') {
+            return i();
+        }
+        else {
+            throw new Error('Not Support Platform ' + $os);
+        }
+    };
+});
+extendsClassMethod(RTCVideo, 'stopLiveVideoCapture', function () {
+    return function impl() {
+        var ins = this[LiveHelperKey];
+        if (!ins) {
+            return -2;
+        }
+        return ins.stopLiveVideoCapture();
+    };
+});
 extendsClassMethod(RTCVideo, 'setVideoEncoderConfig', function (origin) {
     return function impl(channelSolutions) {
         var _this = this;
         var a = function () {
-            var vertc = VertcHelper.getInstance();
+            var vertc = VertcHelper$1.getInstance();
             return vertc.invokeSetVideoEncoderConfig(unpackObject(_this), channelSolutions.map(function (item) { return unpackObject(item); }));
         };
         var i = function () {
@@ -68503,11 +68671,44 @@ extendsClassMethod(RTCVideo, 'setVideoEncoderConfig', function (origin) {
         }
     };
 });
+extendsClassMethod(RTCVideo, 'startPushSingleStreamToCDN', function () {
+    return function impl(taskId, params) {
+        var _this = this;
+        var a = function () {
+            var vertc = VertcHelper$1.getInstance();
+            var streamParams = new PushSingleStreamParam$1();
+            streamParams.roomId = params.roomId;
+            streamParams.userId = params.userId;
+            streamParams.url = params.url;
+            streamParams.isScreen = params.isScreen || false;
+            return vertc.invokeStartPushSingleStreamToCDN(unpackObject(_this), taskId, streamParams);
+        };
+        var i = function () {
+            var vertc = VertcHelper.getInstance();
+            var streamParams = new ByteRTCPushSingleStreamParam();
+            streamParams.roomId = params.roomId;
+            streamParams.userId = params.userId;
+            streamParams.url = params.url;
+            streamParams.isScreen = params.isScreen || false;
+            return vertc.invokeStartPushSingleStreamToCDN(unpackObject(_this), taskId, streamParams);
+        };
+        var $os = env.getOS();
+        if ($os === 'android') {
+            return a().then(Number);
+        }
+        else if ($os === 'ios') {
+            return i().then(Number);
+        }
+        else {
+            throw new Error('Not Support Platform ' + $os);
+        }
+    };
+});
 extendsClassMethod(RTCVideo, 'setLocalVideoMirrorType', function (origin) {
     return function impl(mirrorType) {
         var _this = this;
         var a = function () {
-            var vertc = VertcHelper.getInstance();
+            var vertc = VertcHelper$1.getInstance();
             return vertc.invokeSetLocalVideoMirrorType(unpackObject(_this), t_MirrorType.ts_to_android(mirrorType));
         };
         var i = function () {
@@ -68998,12 +69199,6 @@ var RTCManager = /** @class */ (function () {
         });
         return RTCVideo.setLogConfig(logConfig);
     };
-    /** {en}
-     * @brief Set vod-player instance
-     */
-    RTCManager.prototype.setVodPlayer = function (vodPlayer) {
-        this.vodPlayer = vodPlayer;
-    };
     return RTCManager;
 }());
 

package/lib/typescript/core/callback.d.ts

@@ -4,6 +4,6 @@
 import { RTCStream, type StreamRemoveReason } from '../codegen/pack';
 declare module '../codegen/pack/index.ts' {
     interface RTCRoomEventHandler {
-        onStreamRemove(stream: RTCStream, reason: StreamRemoveReason): void;
+        onStreamRemove?(stream: RTCStream, reason: StreamRemoveReason): void;
     }
 }

package/lib/typescript/core/rtc-video.d.ts

@@ -1,7 +1,7 @@
 // Copyright © 2022 BytePlusRTC All rights reserved.
 // SPDX-License-Identifier: MIT
 
-import { RTCVideo, type ProblemFeedbackOption } from '../codegen/pack';
+import { RTCVideo, type ProblemFeedbackOption, StreamIndex } from '../codegen/pack';
 import type { IFeedbackProblemInfo, IRemoteStreamInfo } from '../interface';
 import './callback';
 declare module '../codegen/pack' {
@@ -11,12 +11,44 @@ declare module '../codegen/pack' {
          */
         fps?: number;
     }
+    interface ILiveCaptureOptions {
+        /**
+         * video streamIndex
+         */
+        streamIndex?: StreamIndex;
+    }
     interface RTCVideo {
         feedback(options: ProblemFeedbackOption[], info: IFeedbackProblemInfo): number;
         setRuntimeParameters(params: Record<string, string>): number;
         setRemoteAudioPlaybackVolume(config: IRemoteStreamInfo, volume: number): void;
+        /** {en}
+         * @brief Start to observe vod player, capture frames from vod player and set stream for external screen stream.
+         * @param player The player instance call by `initPlayer` from `react-native-vod-player` SDK.
+         * @return
+         *         - 0: Success.
+         *         - <0: Failed.
+         */
         startVodPlayerCapture(player: any, options?: IVodPlayerCaptureOptions): Promise<void>;
+        /** {en}
+         * @brief Stop all vod player observer in rtc.
+         * @note Once you invoke this api, you should invoke `startVodPlayerCapture` to observe vod player.
+         */
         stopVodPlayerCapture(player: any): Promise<void>;
+        /** {en}
+         * @brief Start to observe live player, capture frames from live player and set stream for external stream.
+         * @param viewId The live player view id.
+         * @param options ILiveCaptureOptions, Support publish by main stream(default) or screen stream.
+         * @note When pushing through screen streaming, Android has a 5fps limit. If you need to lift the limit, please contact us to handle it for you, or give priority to using camera streaming.
+         * @return
+         *         - 0: Success.
+         *         - <0: Failed.
+         */
+        startLiveVideoCapture(viewId: string, options?: ILiveCaptureOptions): Promise<number>;
+        /** {en}
+         * @brief Stop all vod player observer in rtc.
+         * @note Once you invoke this api, you should invoke `startLiveVideoCapture` to observe live player.
+         */
+        stopLiveVideoCapture(): Promise<number>;
     }
 }
 export { RTCVideo };

package/lib/typescript/core.d.ts

@@ -66,8 +66,4 @@ export declare class RTCManager {
      * @list Engine Management
      */
     setLogConfig(config: ILogConfigs): number;
-    /** {en}
-     * @brief Set vod-player instance
-     */
-    setVodPlayer(vodPlayer: unknown): void;
 }

package/lib/typescript/interface.d.ts

@@ -7,7 +7,7 @@ import { RTCVideo } from './core/rtc-video';
  * @detail api
  * @brief An engine class encapsulated by the {@link RTCVideo RTCVideo} class of the Android/iOS SDK.
  */
-export type IEngine = Omit<RTCVideo, 'setLocalVideoCanvas' | 'createRTCRoom' | 'setCellularEnhancement' | 'enableAudioPropertiesReport' | 'setRemoteAudioPlaybackVolume' | 'getAudioEffectPlayer' | 'getMediaPlayer' | 'setScreenVideoEncoderConfig' | 'startScreenCapture' | 'setRemoteVideoCanvas' | 'requestRemoteVideoKeyFrame' | 'sendStreamSyncInfo' | 'setVideoEncodeConfig'> & {
+export type IEngine = Omit<RTCVideo, 'setLocalVideoCanvas' | 'createRTCRoom' | 'setCellularEnhancement' | 'enableAudioPropertiesReport' | 'setRemoteAudioPlaybackVolume' | 'getAudioEffectPlayer' | 'getMediaPlayer' | 'setScreenVideoEncoderConfig' | 'startScreenCapture' | 'setRemoteVideoCanvas' | 'requestRemoteVideoKeyFrame' | 'sendStreamSyncInfo' | 'setVideoEncodeConfig' | 'startPushSingleStreamToCDN'> & {
     /** {en}
      * @brief Sets the view to be used for local video rendering and the rendering mode.
      * @param streamIndex Video stream type.
@@ -170,6 +170,35 @@ export type IEngine = Omit<RTCVideo, 'setLocalVideoCanvas' | 'createRTCRoom' | '
      *        - This API is applicable to the video stream captured by the camera, see {@link setScreenVideoEncoderConfig setScreenVideoEncoderConfig} for setting parameters for screen sharing video stream.
      */
     setVideoEncoderConfig(channelSolutions: IVideoEncoderConfig[]): number;
+    /** {en}
+     * @brief Start to observe vod player, capture frames from vod player and set stream for external screen stream.
+     * @param player The player instance call by `initPlayer` from `react-native-vod-player` SDK.
+     * @return
+     *         - 0: Success.
+     *         - <0: Failed.
+     */
+    startVodPlayerCapture(player: any): number;
+    /** {en}
+     * @brief Stop all vod player observer in rtc.
+     * @note Once you invoke this api, you should invoke `startVodPlayerCapture` to observe vod player.
+     */
+    stopVodPlayerCapture(player: any): number;
+    /** {en}
+     * @detail api
+     * @region Push to CDN
+     * @brief Create a new task of pushing a single media stream to CDN.
+     * @param taskId Task ID.
+     *        You may want to start more than one task to push streams to CDN. When you do that, use different IDs for corresponding tasks; if you will start only one task, use an empty string.
+     * @param param Configurations for pushing a single stream to CDN. See IPushSingleStreamParam。.
+     * @return
+     *        - 0: Success.
+     *        - < 0 : Fail. See {@link ReturnStatus ReturnStatus} for more details
+     * @note
+     *       - Before calling this API，you need to enable Push to CDN on the [console](https://console.byteplus.com/rtc/workplaceRTC).
+     *       - Call {@link stopPushStreamToCDN stopPushStreamToCDN} to stop the task.
+     *       - Since this API does not perform encoding and decoding, the video stream pushed to RTMP will change according to the resolution, encoding method, and turning off the camera of the end of pushing streams.
+     */
+    startPushSingleStreamToCDN(taskId: string, params: IPushSingleStreamParam): number;
 };
 /** {en}
  * @detail api
@@ -645,6 +674,29 @@ export interface IForwardStreamConfig {
      */
     token: string;
 }
+/** {en}
+ * @detail keytype
+ * @brief Params for stream push to cdn.
+ */
+export interface IPushSingleStreamParam {
+    /** {en}
+     * @brief The room ID of the media stream
+     */
+    roomId: string;
+    /** {en}
+     * @brief The user ID of the media stream
+     */
+    userId: string;
+    /** {en}
+     * @brief The URL for live transcoding. Only supports live transcoding via RTMP. The URL should match the regular expression `/^rtmps?:\\/\\//`. <br>
+     *        This parameter cannot be updated while pushing stream to the CDN.
+     */
+    url: string;
+    /** {en}
+     * @brief Whether the media stream is a screen-sharing stream.
+     */
+    isScreen?: boolean;
+}
 /** {en}
  * @detail keytype
  * @brief Local log parameters.

package/lib/typescript/platforms/android/live.d.ts

@@ -0,0 +1,8 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+import { RTCVideo } from '../../codegen/android';
+export declare class VertcLive {
+    startLiveVideoCapture(video: RTCVideo, viewId: string, options: Record<string, any>): Promise<number>;
+    stopLiveVideoCapture(): Promise<number>;
+}

package/lib/typescript/platforms/android/vertc.d.ts

@@ -3,8 +3,10 @@
 
 import { NativeProxyService } from '@vcloud-lux/hybrid-runtime';
 import { MirrorType, RTCVideo, VideoEncoderConfig } from '../../codegen/android';
+import { IPushSingleStreamParam } from '../../interface';
 export declare class VertcHelper extends NativeProxyService {
     static getInstance(): VertcHelper;
     invokeSetVideoEncoderConfig(video: RTCVideo, channelSolutions: VideoEncoderConfig[]): Promise<number>;
     invokeSetLocalVideoMirrorType(video: RTCVideo, mirrorType: MirrorType): Promise<number>;
+    invokeStartPushSingleStreamToCDN(video: RTCVideo, taskId: string, param: IPushSingleStreamParam): Promise<number>;
 }

package/lib/typescript/platforms/ios/live.d.ts

@@ -0,0 +1,9 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+import { ByteRTCVideo } from '../../codegen/ios';
+export declare class VertcLive {
+    init(): this;
+    startLiveVideoCapture(video: ByteRTCVideo, viewId: string, options: Record<string, any>): Promise<void>;
+    stopLiveVideoCapture(): Promise<void>;
+}

package/lib/typescript/platforms/ios/vertc.d.ts

@@ -0,0 +1,10 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+import { ByteRTCVideo } from '../../codegen/ios';
+import { IPushSingleStreamParam } from '../../interface';
+export declare class VertcHelper {
+    init(): this;
+    static getInstance(): VertcHelper;
+    invokeStartPushSingleStreamToCDN(video: ByteRTCVideo, taskId: string, param: IPushSingleStreamParam): Promise<number>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byteplus/react-native-rtc",
-  "version": "1.0.6",
+  "version": "1.0.7-rc.0",
   "peerDependencies": {
     "react": "*",
     "react-native": "*"

package/react-native-rtc.podspec

@@ -67,8 +67,11 @@ Pod::Spec.new do |s|
     rtc_version_byteplus_non_union = '3.58.1.14800'
     rtc_version = enable_union ? rtc_version_byteplus_union : rtc_version_byteplus_non_union
     if enable_union
-      s.dependency 'TTSDKFramework/RTCSDK', '1.46.300.1-premium'
-      s.dependency 'TTSDKFramework/Player-SR', '1.46.300.1-premium'
+      s.dependency 'TTSDKFramework/RTCSDK', '1.46.300.3-premium'
+      s.dependency 'TTSDKFramework/Player-SR', '1.46.300.3-premium'
+      s.dependency 'TTSDKFramework/Core', '1.46.300.3-premium'
+      s.dependency 'TTSDKFramework/LivePush-RTS', '1.46.300.3-premium'
+      s.dependency 'react-native-velive-push'
     else
       s.dependency 'BytePlusRTC', rtc_version
       s.dependency 'TTSDKFramework/Player-SR', '1.45.300.3-premium'