@byteplus/react-native-rtc 1.0.6 → 1.1.0

package/ios/core/VertcHelper.m

@@ -0,0 +1,42 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+//
+//  react-native-rtc
+//
+
+#import <Foundation/Foundation.h>
+#import "RTCHeader.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 {
+    // Compatible live rtc version.
+    if ([singleStream respondsToSelector:NSSelectorFromString(@"setPushType:")]) {
+        // Can only use 1 magic number.
+        [singleStream setValue:@(1) forKey:@"pushType"];
+    }
+    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;
 }());