@byteplus/react-native-rtc 1.0.2 → 1.0.4

package/lib/module/index.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: MIT
 
 import { NativeEventEmitter, Image, Platform, NativeModules, requireNativeComponent } from 'react-native';
+import React from 'react';
 
 /**
  *  base64.ts
@@ -310,6 +311,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];
@@ -317,6 +329,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) {
@@ -43374,9 +43404,9 @@ var LocalProxyError;
 })(LocalProxyError || (LocalProxyError = {}));
 var MediaStreamType;
 (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";
 })(MediaStreamType || (MediaStreamType = {}));
 var MediaDeviceState;
 (function (MediaDeviceState) {
@@ -67090,7 +67120,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) {
@@ -67154,6 +67184,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[VideoCodecType.VIDEO_CODEC_TYPE_H264] = VideoCodecType.VIDEO_CODEC_TYPE_H264,
+                    _a[VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1] = VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1,
+                    _a[VideoConfig$VideoCodecType.VIDEO_CODEC_TYPE_H264] = VideoCodecType.VIDEO_CODEC_TYPE_H264,
+                    _a[VideoConfig$VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1] = 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[VideoCodecType.VIDEO_CODEC_TYPE_H264] = VideoCodecType.VIDEO_CODEC_TYPE_H264,
+                    _a[VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1] = VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1,
+                    _a[VideoConfig$VideoCodecType.VIDEO_CODEC_TYPE_H264] = VideoCodecType.VIDEO_CODEC_TYPE_H264,
+                    _a[VideoConfig$VideoCodecType.VIDEO_CODEC_TYPE_BYTEVC1] = 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;
@@ -67276,31 +67377,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 = 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') {
@@ -67762,7 +67861,23 @@ var RTCManager = /** @class */ (function () {
 }());
 
 var NativeViewComponentName = 'VertcView';
-var NativeViewComponent = requireNativeComponent(NativeViewComponentName);
+var VertcView = 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

package/lib/typescript/codegen/pack/keytype.d.ts

@@ -5922,9 +5922,9 @@ export declare enum LocalProxyError {
     HTTP_TUNNEL_FAILED = 6
 }
 export declare enum MediaStreamType {
-    RTC_MEDIA_STREAM_TYPE_AUDIO = 0,
-    RTC_MEDIA_STREAM_TYPE_VIDEO = 1,
-    RTC_MEDIA_STREAM_TYPE_BOTH = 2
+    RTC_MEDIA_STREAM_TYPE_AUDIO = 1,
+    RTC_MEDIA_STREAM_TYPE_VIDEO = 2,
+    RTC_MEDIA_STREAM_TYPE_BOTH = 3
 }
 export declare enum MediaDeviceState {
     /** {en}

package/lib/typescript/component.d.ts

@@ -1,11 +1,18 @@
 // Copyright © 2022 BytePlusRTC All rights reserved.
 // SPDX-License-Identifier: MIT
 
-export type NativeViewComponentProps = {
+import React from 'react';
+type VertcViewProps = {
     viewId: string;
     kind: 'SurfaceView' | 'TextureView' | 'View' | 'UIView';
     children?: any;
     style?: any;
+    onViewLoad?: () => void;
+};
+export type NativeViewComponentProps = Omit<VertcViewProps, 'onViewLoad'> & {
     onLoad?: () => void;
 };
-export declare const NativeViewComponent: import("react-native").HostComponent<NativeViewComponentProps>;
+export declare class NativeViewComponent extends React.Component<NativeViewComponentProps> {
+    render(): React.ReactNode;
+}
+export {};

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

@@ -3,12 +3,19 @@
 
 import { RTCVideo, type ProblemFeedbackOption } from '../codegen/pack';
 import type { IFeedbackProblemInfo, IRemoteStreamInfo } from '../interface';
+import './callback';
 declare module '../codegen/pack' {
+    interface IVodPlayerCaptureOptions {
+        /**
+         * video fps
+         */
+        fps?: number;
+    }
     interface RTCVideo {
         feedback(options: ProblemFeedbackOption[], info: IFeedbackProblemInfo): number;
         setRuntimeParameters(params: Record<string, string>): number;
         setRemoteAudioPlaybackVolume(config: IRemoteStreamInfo, volume: number): void;
-        startVodPlayerCapture(player: any): Promise<void>;
+        startVodPlayerCapture(player: any, options?: IVodPlayerCaptureOptions): Promise<void>;
         stopVodPlayerCapture(player: any): Promise<void>;
     }
 }

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

@@ -1,8 +1,8 @@
 // Copyright © 2022 BytePlusRTC All rights reserved.
 // SPDX-License-Identifier: MIT
 
-import { RTCVideo, type StreamIndex } from '../../codegen/android';
+import { RTCVideo } from '../../codegen/android';
 export declare class VertcVod {
-    startVodPlayerCapture(video: RTCVideo, player: any, streamIndex: StreamIndex): Promise<void>;
+    startVodPlayerCapture(video: RTCVideo, player: any, options: Record<string, any>): Promise<void>;
     stopVodPlayerCapture(video: RTCVideo): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byteplus/react-native-rtc",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "peerDependencies": {
     "react": "*",
     "react-native": "*"

package/react-native-rtc.podspec

@@ -22,8 +22,16 @@ Pod::Spec.new do |s|
   s.authors      = package["author"]
 
   s.platforms    = { :ios => min_ios_version_supported }
-  # s.source       = { :git => "https://github.com/volcengine/volcengine-specs.git", :tag => "#{s.version}" }
-  s.source       = { :git => "https://github.com/byteplus-sdk/byteplus-specs.git", :tag => "#{s.version}" }
+
+  if is_bp
+    s.source       = { :git => "https://github.com/byteplus-sdk/byteplus-specs.git", :tag => "#{s.version}" }
+  else
+    s.source       = { :git => "https://github.com/volcengine/volcengine-specs.git", :tag => "#{s.version}" }
+  end
+
+  s.pod_target_xcconfig = {
+    'ENABLE_UNION_FOR_RTC_WITH_LIVE' => '$(ENABLE_UNION_FOR_RTC_WITH_LIVE)'
+  }
 
   s.source_files = "ios/**/*.{h,m,mm}"
 
@@ -37,11 +45,11 @@ Pod::Spec.new do |s|
   # Don't install the dependencies when we run `pod install` in the old architecture.
   if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
     s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
-    s.pod_target_xcconfig    = {
+    s.pod_target_xcconfig.merge!({
         "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
         "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
         "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
-    }
+    })
     s.dependency "React-Codegen"
     s.dependency "RCT-Folly"
     s.dependency "RCTRequired"
@@ -50,19 +58,34 @@ Pod::Spec.new do |s|
    end
   end
 
-  s.dependency 'VolcApiEngine', '1.4.0'
+  s.dependency 'VolcApiEngine', '1.6.2'
   
-  # if (is_bp) then
-  s.dependency 'BytePlusRTC', '3.58.1.14800'
-  # else 
+  enable_union = (ENV['ENABLE_UNION_FOR_RTC_WITH_LIVE'] == 'YES')
 
-  # end
+  if is_bp
+    rtc_version_byteplus_union = '3.58.1.45300'
+    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'
+    else
+      s.dependency 'BytePlusRTC', rtc_version
+      s.dependency 'TTSDKFramework/Player-SR', '1.45.300.3-premium'
+    end
+    puts "React-Native-RTC Pod: Using BytePlusRTC SDK version: #{rtc_version} (union build enabled: #{enable_union})"
+  else
+    rtc_version_volc_union = '3.58.1.100'
+    rtc_version_volc_non_union = '3.58.1.100'
+    rtc_version = enable_union ? rtc_version_volc_union : rtc_version_volc_non_union
+    if enable_union
+      s.dependency 'TTSDKFramework/RTCSDK', '1.46.3.9-premium'
+      s.dependency 'TTSDKFramework/Player-SR', '1.46.3.9-premium'
+    else
+      s.dependency 'VolcEngineRTC', rtc_version
+      s.dependency 'TTSDKFramework/Player-SR', '1.46.2.8-premium'
+    end
 
-  
-  # TTVideoEngine
-  # byteplus and volcengine use same name, different version
-  # volcengine     1.43.1.9-premium        1.43.1.9-standard
-  # byteplus       1.45.300.3-premium      1.45.300.3-standard
-  # For 1.0.1-rc.3 version.
-  s.dependency 'TTSDKFramework/Player-SR', '1.45.300.3-premium'
+    puts "React-Native-RTC Pod: Using VolcEngineRTC SDK version: #{rtc_version} (union build enabled: #{enable_union})"
+  end
 end

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

@@ -1,44 +0,0 @@
-// Copyright © 2022 BytePlusRTC All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package com.volcengine.reactnative.vertc.vod;
-
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.ss.bytertc.engine.RTCVideo;
-import com.ss.bytertc.engine.data.AudioSourceType;
-import com.ss.ttm.player.TraitObject;
-import com.ss.ttvideoengine.TTVideoEngine;
-
-public class VodAudioProxy {
-  private String TAG = "VodAudioProxy";
-
-  private TTVideoEngine mVideoEngine;
-  private RTCVideo mRTCVideo;
-
-  public void initEngine(TTVideoEngine videoEngine, RTCVideo rtcEngine, ReactApplicationContext reactApplicationContext) {
-    mVideoEngine = videoEngine;
-    mRTCVideo = rtcEngine;
-    rtcEngine.setScreenAudioSourceType(AudioSourceType.AUDIO_SOURCE_TYPE_EXTERNAL);
-
-//    var mVAProcessor = new 
-//    mVideoEngine.setAudioProcessor(mVAProcessor);
-    
-//    TraitObject traitObj = new VodAudioVoiceWrapperObject(reactApplicationContext.getApplicationContext(), rtcEngine);
-//    mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_SET_VOICE, TTVideoEngine.VOICE_EXTERN);
-//    mVideoEngine.setTraitObject(TraitObject.ExtVoice, traitObj);
-
-//    mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_EXTERN_VOICE_OUTPUT_FORMAT, VoiceTrait.AV_PCM_FMT_S16);
-
-//    mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_SET_VOICE, TTVideoEngine.VOICE_DUMMY);
-//    mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_DUMMY_AUDIO_SLEEP, 0);
-  }
-  
-  public void release() {
-    if (mVideoEngine != null) {
-      mVideoEngine = null;
-    }
-    if (mRTCVideo != null) {
-      mRTCVideo = null;
-    }
-  }
-}