@byteplus/react-native-rtc 1.0.2 → 1.0.4

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

@@ -20,14 +20,16 @@ import java.nio.ByteBuffer;
 import java.util.concurrent.TimeUnit;
 
 public class VideoAudioProcessor extends AudioProcessor {
-  public String TAG = "VideoAudioProcessor";
-  
-  private final VodAudioProcessor processor;
-    private final RTCVideo mRTCEngine;
+    public String TAG = "VideoAudioProcessor";
 
-    public VideoAudioProcessor(RTCVideo engine) {
+    private org.json.JSONObject mOptions;
+    private final VodAudioProcessor processor;
+    private final RTCVideo mRTCEngine;
+    
+    public VideoAudioProcessor(RTCVideo engine, org.json.JSONObject options) {
         processor = new VodAudioProcessor(engine);
         mRTCEngine = engine;  
+        mOptions = options;
     }
    
     public void updateScreenConfig(int width, int height) {
@@ -38,7 +40,6 @@ public class VideoAudioProcessor extends AudioProcessor {
         videoEncoderConfig.height = height;
         videoEncoderConfig.encodePreference = ScreenVideoEncoderConfig.EncoderPreference.MaintainFramerate;
         mRTCEngine.setScreenVideoEncoderConfig(videoEncoderConfig);
-//        mRTCEngine.publishScreen(RTCEngine.MediaStreamType.RTC_MEDIA_STREAM_TYPE_BOTH);
     }
 
     @Override
@@ -53,7 +54,6 @@ public class VideoAudioProcessor extends AudioProcessor {
 
     @Override
     public void audioClose() {
-
     }
 
     @Override
@@ -61,16 +61,14 @@ public class VideoAudioProcessor extends AudioProcessor {
 
     }
 
-    public void onFrameAvailable(EGLContext eglContext, int oesTextureId, float[] transformMatrix, int width, int height) {
-     long nanoTime = System.currentTimeMillis() * TimeUnit.MILLISECONDS.toNanos(1);
+    public void onFrameAvailable(EGLContext eglContext, int oesTextureId, float[] transformMatrix, int width, int height, long timestamp) {
      GLTextureVideoFrameBuilder builder = new GLTextureVideoFrameBuilder(VideoPixelFormat.TEXTURE_OES)
        .setTextureID(oesTextureId)
        .setWidth(width)
        .setHeight(height)
        .setRotation(VideoRotation.VIDEO_ROTATION_0)
        .setTextureMatrix(transformMatrix)
-       .setTimeStampUs(nanoTime)
-       .setColorSpace(ColorSpace.UNKNOWN)
+       .setTimeStampUs(timestamp)
        .setEGLContext(eglContext);
      int ret_status = mRTCEngine.pushScreenVideoFrame(builder.build());
      boolean result = ret_status == ReturnStatus.RETURN_STATUS_SUCCESS.value()

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

@@ -5,36 +5,47 @@ package com.volcengine.reactnative.vertc.vod;
 
 import android.os.Handler;
 import android.os.Looper;
-import android.util.Log;
 
 import com.ss.bytertc.engine.RTCVideo;
+import com.ss.bytertc.engine.data.AudioSourceType;
+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 com.ss.bytertc.engine.video.VideoFrame;
 import com.ss.bytertc.engine.video.builder.CpuBufferVideoFrameBuilder;
 
 import java.nio.ByteBuffer;
 import java.util.concurrent.TimeUnit;
 
+// For Test pushScreenVideoFrame
 public class VodMock {
-  public String TAG = "VideoAudioProcessor";
+  public String TAG = "VodMockTest";
 
   private final RTCVideo mRTCEngine;
+  private final int mFps;
 
   public VodMock(RTCVideo engine) {
     mRTCEngine = engine;
+    mFps = 30;
   }
   
-  public void useFakeVideoFrame() {
+  public void start() {
+    mRTCEngine.setScreenAudioSourceType(AudioSourceType.AUDIO_SOURCE_TYPE_EXTERNAL);
+    mRTCEngine.setVideoSourceType(StreamIndex.STREAM_INDEX_SCREEN, VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL);
+    useFakeVideoFrame();
+  }
+  
+  private void useFakeVideoFrame() {
     final Handler handler = new Handler(Looper.getMainLooper());
     var width = 998;
     var height = 554;
     Runnable runnable = new Runnable() {
       @Override
       public void run() {
-        handler.postDelayed(this, 30);  // Repeats every 5 seconds
+        handler.postDelayed(this, 1000 / mFps); 
 
-        var frame = useInternalVideoFrame(width, height);
+        var frame = buildInternalVideoFrame(width, height);
         mRTCEngine.pushScreenVideoFrame(frame);
 //        Log.d(TAG, "pushScreenVideoFrame");
       }
@@ -42,7 +53,7 @@ public class VodMock {
     handler.post(runnable);
   }
 
-  public VideoFrame useInternalVideoFrame(int width, int height){
+  private VideoFrame buildInternalVideoFrame(int width, int height){
     int chromaWidth = (width + 1) / 2;
     int chromaHeight = (height + 1) /2;
     int uvSize = chromaWidth * chromaHeight;

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

@@ -0,0 +1,94 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package com.volcengine.reactnative.vertc.vod;
+
+import android.util.Log;
+
+import com.ss.ttvideoengine.TTVideoEngine;
+import com.ss.ttvideoengine.VideoEngineCallback;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+// TTVideoEngine 只会保存一个 VideoEngineCallback
+// 但是我们需要监听 VideoEngineCallback，会和用户设置的 VideoEngineCallback 冲突
+// 因此，我们添加一层代理，同时触发用户的 VideoEngineCallback 和我们内部的 VideoEngineCallback
+// 结束后再 reset
+public class VodVideoEngineCallbackProxy implements VideoEngineCallback {
+  public final String TAG = "VodVideoEngineCallback";
+  
+  public VideoEngineCallback mOriginalCallback = null;
+  public VideoEngineCallback mCallback = null;
+  public VideoEngineCallback mProxyCallback = null;
+  
+  public VodVideoEngineCallbackProxy(TTVideoEngine ttVideoEngine, VideoEngineCallback callback) {
+    mCallback = callback;
+    mOriginalCallback = findOriginalCallback(ttVideoEngine);
+  }
+  
+  public VideoEngineCallback listen() {
+    Class<VideoEngineCallback> clazz = VideoEngineCallback.class;
+    Object dynamicObserver = Proxy.newProxyInstance(
+      clazz.getClassLoader(), // 使用Observer接口的类加载器
+      new Class[]{clazz}, // 指定要代理的接口
+      (proxy, method, args) -> {
+        if (mOriginalCallback != null) {
+          triggerCallback(method, args);
+          return invokeOriginal(method, args);
+        }
+        return triggerCallback(method, args);
+      }
+    );
+    mProxyCallback = (VideoEngineCallback) dynamicObserver;
+    return mProxyCallback;
+  }
+
+  public void reset(TTVideoEngine ttVideoEngine) {
+    if (ttVideoEngine != null) {
+      if (findOriginalCallback(ttVideoEngine) == mProxyCallback) {
+        ttVideoEngine.setVideoEngineCallback(mOriginalCallback);
+      }
+    }
+  }
+  
+  private Object invokeOriginal(Method method, Object[] args) {
+    try {
+      Method originalCallbackMethod = mOriginalCallback.getClass().getMethod(method.getName(), method.getParameterTypes());
+      return originalCallbackMethod.invoke(mOriginalCallback, args);
+    } catch (Exception ignore) {
+      return null;
+    }
+  }
+
+  private Object triggerCallback(Method method, Object[] args) {
+    try {
+      Method cbMethod = mCallback.getClass().getMethod(method.getName(), method.getParameterTypes());
+      return cbMethod.invoke(mCallback, args);
+    } catch (Exception ignore) {
+      return null;
+    }
+  }
+  
+  private VideoEngineCallback findOriginalCallback(TTVideoEngine ttVideoEngine) {
+    if (ttVideoEngine == null) {
+      return null;
+    }
+    try {
+      Field mVideoEngineField = TTVideoEngine.class.getDeclaredField("mVideoEngine");
+      mVideoEngineField.setAccessible(true);
+      Object mVideoEngine = mVideoEngineField.get(ttVideoEngine);
+      Field mListenerCompactField = mVideoEngine.getClass().getDeclaredField("mListenerCompact");
+      mListenerCompactField.setAccessible(true);
+      Object mListenerCompact = mListenerCompactField.get(mVideoEngine);
+      Field mEngineCallbackField = mListenerCompact.getClass().getDeclaredField("mEngineCallback");
+      mEngineCallbackField.setAccessible(true);
+      Object mEngineCallback = mEngineCallbackField.get(mListenerCompact);
+      return  (VideoEngineCallback) mEngineCallback;
+    } catch (Exception e) {
+      Log.w(TAG, "can't find original TTVideoEngine Callback, reason: " + e.getMessage());
+      return null;
+    }
+  }
+}

package/ios/VertcView.m

@@ -31,7 +31,7 @@
   [self emitLoaded];
 }
 
-- (void) setOnLoad:(RCTBubblingEventBlock)onLoad {
+- (void) setOnViewLoad:(RCTBubblingEventBlock)onLoad {
   _onLoad = onLoad;
 
   [self emitLoaded];

package/ios/VertcViewManager.m

@@ -21,7 +21,7 @@
 
 RCT_EXPORT_MODULE(VertcViewManager)
 
-RCT_EXPORT_VIEW_PROPERTY(onLoad, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onViewLoad, RCTBubblingEventBlock)
 
 RCT_CUSTOM_VIEW_PROPERTY(viewId, NSString, VertcView)
 {

package/ios/vod/VertcVod.m

@@ -12,6 +12,7 @@
 
 @interface VertcVod ()
 
+@property (nonatomic, strong) NSDictionary *options;
 @property (nonatomic, strong) ByteRTCVideo *rtcEngine;
 @property (nonatomic, strong) TTVideoEngine *videoEngine;
 @property (nonatomic, strong) VodAudioProcessor *audioProcesser;
@@ -49,9 +50,13 @@
     }
     
     self.rtcEngine = rtc;
+    self.options = options;
     self.videoEngine = videoEngine;
-    self.audioProcesser = [[VodAudioProcessor alloc] initWithRTCKit:rtc];
-    self.videoProcesser = [[VodVideoProcessor alloc] initWithRTCKit:rtc];
+    self.audioProcesser = [[VodAudioProcessor alloc] initWithRTCKit:rtc options:options];
+    self.videoProcesser = [[VodVideoProcessor alloc] initWithRTCKit:rtc options:options];
+    
+    [rtc setVideoSourceType:ByteRTCVideoSourceTypeExternal WithStreamIndex:ByteRTCStreamIndexScreen];
+    [rtc setScreenAudioSourceType:ByteRTCAudioSourceTypeExternal];
     
     ttAudioWrapper.open = openAudio;
     ttAudioWrapper.process = processAudio;
@@ -70,9 +75,16 @@
 
 - (int) stopVodPlayerCapture:(ByteRTCVideo *)rtc;
 {
+    [self.videoEngine setAudioProcessor:NULL];
+    self.audioProcesser = nil;
+    self.videoProcesser = nil;
     ttAudioWrapper.context = NULL;
     ttVideoWrapper.context = NULL;
     [rtc setVideoSourceType:ByteRTCVideoSourceTypeInternal WithStreamIndex:ByteRTCStreamIndexScreen];
+    [rtc setScreenAudioSourceType:ByteRTCAudioSourceTypeInternal];
+    self.options = nil;
+    self.rtcEngine = nil;
+    self.videoEngine = nil;
     return 0;
 }
 
@@ -99,11 +111,13 @@ static void processAudio (void *context, float **inouts, int samples, int64_t ti
 }
 
 static void closeAudio (void *context) {
-    
+    VodAudioProcessor *process = (__bridge VodAudioProcessor *)(context);
+    [process closeAudio];
 }
 
 static void releaseAudio (void *context) {
-    
+    VodAudioProcessor *process = (__bridge VodAudioProcessor *)(context);
+    [process releaseAudio];
 }
 
 
@@ -114,7 +128,8 @@ static void videoProcessFunc(void *context, CVPixelBufferRef frame, int64_t time
 }
 
 static void videoReleaseFunc(void *context) {
-    
+    VodVideoProcessor *process = (__bridge VodVideoProcessor *)(context);
+    [process releaseVideo];
 }
 
 @end

package/ios/vod/VodAudioProcessor.h

@@ -19,7 +19,7 @@ extern int VoidAudioMixingID;
 
 /// Initialize
 /// @param rtcKit ByteRTCEngineKit
-- (instancetype)initWithRTCKit:(ByteRTCVideo *)rtcKit;
+- (instancetype)initWithRTCKit:(ByteRTCVideo *)rtcKit options:(NSDictionary *)options;
 
 /// Open audio
 /// @param samplerate Samplerate
@@ -31,5 +31,10 @@ extern int VoidAudioMixingID;
 /// @param samples Samples
 - (void)processAudio:(float **)inouts samples:(int)samples timestamp:(int64_t)timestamp;
 
+/// Close audio
+- (void)closeAudio;
+
+/// Release audio
+- (void)releaseAudio;
 
 @end

package/ios/vod/VodAudioProcessor.mm

@@ -13,6 +13,7 @@ int VoidAudioMixingID = 3001;
 @interface VodAudioProcessor ()
 
 @property (nonatomic, weak) ByteRTCVideo *rtcKit;
+@property (nonatomic, weak) NSDictionary *options;
 @property (nonatomic, assign) int length;
 
 @end
@@ -25,9 +26,10 @@ int VoidAudioMixingID = 3001;
     int64_t _lastTimestamp;
 }
 
-- (instancetype)initWithRTCKit:(ByteRTCVideo *)rtcKit {
+- (instancetype)initWithRTCKit:(ByteRTCVideo *)rtcKit options:(NSDictionary *)options {
     if (self = [super init]) {
         self.rtcKit = rtcKit;
+        self.options = options;
         _lastDiffTimestamp = 0;
         _lastTimestamp = 0;
         [rtcKit setScreenAudioSourceType:ByteRTCAudioSourceTypeExternal];
@@ -40,6 +42,12 @@ int VoidAudioMixingID = 3001;
     _channels = channels;
 }
 
+- (void)closeAudio {
+}
+
+- (void)releaseAudio {
+}
+
 - (void)processAudio:(float **)inouts samples:(int)samples timestamp:(int64_t)timestamp {
     NSTimeInterval time = [[NSDate dateWithTimeIntervalSinceNow:0] timeIntervalSince1970] * 1000;
     NSTimeInterval diffTime = (time - _lastDiffTimestamp);

package/ios/vod/VodVideoProcessor.h

@@ -16,11 +16,13 @@
 
 /// Initialize
 /// @param rtcKit ByteRTCEngineKit
-- (instancetype)initWithRTCKit:(ByteRTCVideo *)rtcKit;
+- (instancetype)initWithRTCKit:(ByteRTCVideo *)rtcKit options:(NSDictionary *)options;
 
 /// Process video
 /// @param frame Video pixel buffer
 /// @param timestamp Timestamp
 - (void)processVideo:(CVPixelBufferRef)frame timestamp:(int64_t)timestamp;
 
+- (void)releaseVideo;
+
 @end

package/ios/vod/VodVideoProcessor.m

@@ -14,21 +14,41 @@
 @interface VodVideoProcessor ()
 
 @property (nonatomic, weak) ByteRTCVideo *rtcKit;
+@property (nonatomic, weak) NSDictionary *options;
+@property (nonatomic, assign) NSInteger time;
+@property (nonatomic, assign) int fps;
 
 @end
 
 @implementation VodVideoProcessor
 
-- (instancetype)initWithRTCKit:(ByteRTCVideo *)rtcKit {
+- (instancetype)initWithRTCKit:(ByteRTCVideo *)rtcKit options:(NSDictionary *)options {
     if (self = [super init]) {
         self.rtcKit = rtcKit;
+        self.options = options;
+        self.fps = [[options valueForKey:@"fps"] intValue];
+        self.time = 0;
         [rtcKit setVideoSourceType:ByteRTCVideoSourceTypeExternal WithStreamIndex:ByteRTCStreamIndexScreen];
     }
     return self;
 }
 
 - (void)processVideo:(CVPixelBufferRef)frame timestamp:(int64_t)timestamp {
-    [self.rtcKit pushScreenVideoFrame:frame time:CMTimeMake(timestamp, 1) rotation:0];
+    if (_fps < 1) {
+        if (timestamp > 0) {
+            _fps = 1000 / (timestamp - 0);
+            NSLog(@"detect video fps=%d", _fps);
+        }
+    }
+    int res = [self.rtcKit pushScreenVideoFrame:frame time:CMTimeMake(self.time, self.fps) rotation:0];
+    if (res != 0) {
+        NSLog(@"bytertc pushScreenVideoFrame fail return '%d'", res);
+    }
+    self.time += 1;
+}
+
+- (void)releaseVideo {
+    NSLog(@"video release");
 }
 
 @end

package/lib/commonjs/index.js

@@ -4,6 +4,7 @@
 'use strict';
 
 var reactNative = require('react-native');
+var React = require('react');
 
 /**
  *  base64.ts
@@ -312,6 +313,17 @@ function packObject(receiver, ctor) {
 function unpackObject(proxyInstance, _nativeClass) {
     return proxyInstance._instance;
 }
+
+function findProto(ctor, name) {
+    let proto = ctor.prototype;
+    while (proto) {
+        if (Object.getOwnPropertyDescriptor(proto, name)) {
+            return proto;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return undefined;
+}
 function extendsClassMethod(ctor, methodName, overrideFn) {
     const proto = ctor.prototype;
     const originalFn = ctor.prototype[methodName];
@@ -319,6 +331,24 @@ function extendsClassMethod(ctor, methodName, overrideFn) {
         return overrideFn(originalFn?.bind(this)).apply(this, args);
     };
 }
+function extendsClassMember(ctor, memberName) {
+    return (handler) => {
+        const targetProto = findProto(ctor, memberName);
+        const originalDesc = targetProto
+            ? Object.getOwnPropertyDescriptor(targetProto, memberName)
+            : undefined;
+        const newDesc = handler({
+            getter: originalDesc?.get,
+            setter: originalDesc?.set,
+        });
+        Object.defineProperty(ctor.prototype, memberName, {
+            enumerable: originalDesc?.enumerable ?? true,
+            configurable: originalDesc?.configurable ?? true,
+            get: newDesc.getter || originalDesc?.get,
+            set: newDesc.setter || originalDesc?.set,
+        });
+    };
+}
 
 let impl;
 function setupEnv(e) {
@@ -43376,9 +43406,9 @@ exports.LocalProxyError = void 0;
 })(exports.LocalProxyError || (exports.LocalProxyError = {}));
 exports.MediaStreamType = void 0;
 (function (MediaStreamType) {
-    MediaStreamType[MediaStreamType["RTC_MEDIA_STREAM_TYPE_AUDIO"] = 0] = "RTC_MEDIA_STREAM_TYPE_AUDIO";
-    MediaStreamType[MediaStreamType["RTC_MEDIA_STREAM_TYPE_VIDEO"] = 1] = "RTC_MEDIA_STREAM_TYPE_VIDEO";
-    MediaStreamType[MediaStreamType["RTC_MEDIA_STREAM_TYPE_BOTH"] = 2] = "RTC_MEDIA_STREAM_TYPE_BOTH";
+    MediaStreamType[MediaStreamType["RTC_MEDIA_STREAM_TYPE_AUDIO"] = 1] = "RTC_MEDIA_STREAM_TYPE_AUDIO";
+    MediaStreamType[MediaStreamType["RTC_MEDIA_STREAM_TYPE_VIDEO"] = 2] = "RTC_MEDIA_STREAM_TYPE_VIDEO";
+    MediaStreamType[MediaStreamType["RTC_MEDIA_STREAM_TYPE_BOTH"] = 3] = "RTC_MEDIA_STREAM_TYPE_BOTH";
 })(exports.MediaStreamType || (exports.MediaStreamType = {}));
 exports.MediaDeviceState = void 0;
 (function (MediaDeviceState) {
@@ -67092,7 +67122,7 @@ var VertcVod$1 = function () {
         function VertcVod_1() {
             __runInitializers(this, _instanceExtraInitializers);
         }
-        VertcVod_1.prototype.startVodPlayerCapture = function (video, player, streamIndex) {
+        VertcVod_1.prototype.startVodPlayerCapture = function (video, player, options) {
             throw new Error('not implement');
         };
         VertcVod_1.prototype.stopVodPlayerCapture = function (video) {
@@ -67156,6 +67186,77 @@ var VertcVod = function () {
     return _classThis;
 }();
 
+extendsClassMember(LocalVideoStats, 'codecType')(function () {
+    return {
+        getter: function () {
+            var _a;
+            var $os = env.getOS();
+            if ($os === 'android') {
+                var value = this._instance.codecType;
+                var $m = (_a = {},
+                    _a[exports.VideoCodecType.VIDEO_CODEC_TYPE_H264] = exports.VideoCodecType.VIDEO_CODEC_TYPE_H264,
+                    _a[exports.VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1] = exports.VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1,
+                    _a[VideoConfig$VideoCodecType.VIDEO_CODEC_TYPE_H264] = exports.VideoCodecType.VIDEO_CODEC_TYPE_H264,
+                    _a[VideoConfig$VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1] = exports.VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1,
+                    _a);
+                if (!(value in $m)) {
+                    throw new Error('invalid value:' + value);
+                }
+                // @ts-ignore
+                return $m[value];
+            }
+            else if ($os === 'ios') {
+                return t_VideoCodecType.ios_to_ts(this._instance.codecType);
+            }
+            else {
+                throw new Error('Not Support Platform ' + $os);
+            }
+        },
+    };
+});
+extendsClassMember(RemoteVideoStats, 'codecType')(function () {
+    return {
+        getter: function () {
+            var _a;
+            var $os = env.getOS();
+            if ($os === 'android') {
+                var value = this._instance.codecType;
+                var $m = (_a = {},
+                    _a[exports.VideoCodecType.VIDEO_CODEC_TYPE_H264] = exports.VideoCodecType.VIDEO_CODEC_TYPE_H264,
+                    _a[exports.VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1] = exports.VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1,
+                    _a[VideoConfig$VideoCodecType.VIDEO_CODEC_TYPE_H264] = exports.VideoCodecType.VIDEO_CODEC_TYPE_H264,
+                    _a[VideoConfig$VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1] = exports.VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1,
+                    _a);
+                if (!(value in $m)) {
+                    throw new Error('invalid value:' + value);
+                }
+                // @ts-ignore
+                return $m[value];
+            }
+            else if ($os === 'ios') {
+                return t_VideoCodecType.ios_to_ts(this._instance.codecType);
+            }
+            else {
+                throw new Error('Not Support Platform ' + $os);
+            }
+        },
+    };
+});
+extendsClassMethod(android_RTCRoomEventHandler, 'onStreamRemove', function () {
+    return function impl(stream, reason) {
+        if (this._instance.onStreamRemove) {
+            this._instance.onStreamRemove(packObject(stream, RTCStream), t_StreamRemoveReason.android_to_ts(reason));
+        }
+    };
+});
+extendsClassMethod(ios_RTCRoomEventHandler, 'rtcRoom$onStreamRemove$stream$reason', function () {
+    return function impl(rtcRoom, uid, stream, reason) {
+        if (this._instance.onStreamRemove) {
+            this._instance.onStreamRemove(packObject(stream, RTCStream), t_StreamRemoveReason.ios_to_ts(reason));
+        }
+    };
+});
+
 extendsClassMethod(RTCVideo, 'feedback', function () {
     return function impl(options, info) {
         var _this = this;
@@ -67278,31 +67379,29 @@ extendsClassMethod(RTCVideo, 'setRemoteAudioPlaybackVolume', function () {
 });
 var VodHelperKey = '_vod';
 extendsClassMethod(RTCVideo, 'startVodPlayerCapture', function () {
-    return function impl(player) {
+    return function impl(player, options) {
         var _this = this;
-        var streamIndex = exports.StreamIndex.STREAM_INDEX_SCREEN;
+        if (options === void 0) { options = {}; }
+        if (!player) {
+            throw new Error('Vod player instance is required.');
+        }
+        var unpackedPlayer = unpackObject(player);
         var a = function () {
             var androidRtc = unpackObject(_this);
-            var androidStreamIndex = t_StreamIndex.ts_to_android(streamIndex);
-            // androidRtc.setVideoSourceType(
-            //   androidStreamIndex,
-            //   $p_a.VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL,
-            // );
-            // androidRtc.setScreenAudioSourceType(
-            //   $p_a.AudioSourceType.AUDIO_SOURCE_TYPE_EXTERNAL,
-            // );
             var ins = new VertcVod$1();
             _this[VodHelperKey] = ins;
-            return ins.startVodPlayerCapture(androidRtc, unpackObject(player), androidStreamIndex);
+            return ins.startVodPlayerCapture(androidRtc, unpackedPlayer, options);
         };
         var i = function () {
             var iosRtc = unpackObject(_this);
             var ins = new VertcVod();
             _this[VodHelperKey] = ins;
-            return ins.startVodPlayerCapture(iosRtc, unpackObject(player), {});
+            return ins.startVodPlayerCapture(iosRtc, unpackedPlayer, options);
         };
         var $os = env.getOS();
         if ($os === 'android') {
+            // Using surface texutre for rendering.
+            unpackedPlayer.setIntOption(199, 0);
             return a();
         }
         else if ($os === 'ios') {
@@ -67764,7 +67863,23 @@ var RTCManager = /** @class */ (function () {
 }());
 
 var NativeViewComponentName = 'VertcView';
-var NativeViewComponent = reactNative.requireNativeComponent(NativeViewComponentName);
+var VertcView = reactNative.requireNativeComponent(NativeViewComponentName);
+var NativeViewComponent = /** @class */ (function (_super) {
+    __extends(NativeViewComponent, _super);
+    function NativeViewComponent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NativeViewComponent.prototype.render = function () {
+        var _a = this.props, viewId = _a.viewId, kind = _a.kind, children = _a.children, style = _a.style, onLoad = _a.onLoad;
+        return React.createElement(VertcView, {
+            viewId: viewId,
+            kind: kind,
+            style: style,
+            onViewLoad: onLoad,
+        }, children);
+    };
+    return NativeViewComponent;
+}(React.Component));
 
 /** {en}
  * @detail keytype