@byteplus/react-native-rtc 1.0.6 → 1.1.0

package/README.md

@@ -138,12 +138,6 @@ const Login = () => {
             extras: {
                 source_language: room.language,
             },
-            roomConfigs: {
-                profile: room.roomMode,
-                isAutoPublish: room.autoPublish,
-                isAutoSubscribeAudio: room.autoSubscribeAudio,
-                isAutoSubscribeVideo: room.autoSubscribeVideo,
-            },
         });
 
         /** Capture local streams */
@@ -171,316 +165,6 @@ const Login = () => {
 
 export default Login;
 ```
-
-## On-Demand Video with Real-Time Guest Interaction Example
-
-**We recommend using the latest RTC React Native SDK version in combination with react-native-vod-player SDK v1.2.4.**
-
-
-### RTC Core Definition
-`@/core/index.ts`
-
-Based on the rtc core definition in `Basic Example`, add some apis:
-```typescript
-...
-import type { TTVideoEngine } from '@byteplus/react-native-vod-player';
-
-class RTCClient {
-
-    ...
-
-    /**
-     * @brief Start to observe vod player, capture frames from vod player and set stream for external screen stream.
-     */
-    startVodPlayerCapture(player: TTVideoEngine) {
-        return this.engine?.startVodPlayerCapture(player);
-    }
-
-    /**
-     * @brief Stop all vod player observer in rtc.
-     * @note Once you invoke this api, you should invoke `startVodPlayerCapture` to observe vod player.
-     */
-    stopVodPlayerCapture(player: TTVideoEngine) {
-        return this.engine?.stopVodPlayerCapture(player);
-    }
-}
-```
-### Main logic page in react-native
-`@/page/vodRtc.ts`
-
-```typescript
-import React, {useEffect, useRef, useState} from 'react';
-import fs from 'react-native-fs';
-import {Platform, SafeAreaView, ScrollView} from 'react-native';
-import {Button, Input, Text, Toast, View} from '@ant-design/react-native';
-import {
-  NativeViewComponent,
-  StreamIndex,
-  RenderMode,
-  MediaStreamType,
-  LocalLogLevel,
-} from '@byteplus/react-native-rtc';
-import {
-  createDirectUrlSource,
-  type TTVideoEngine,
-} from '@byteplus/react-native-vod-player';
-import {
-  launchImageLibrary,
-  type ImagePickerResponse,
-} from 'react-native-image-picker';
-import RTCClient from '@/core';
-import { createVeplayer } from '@/core/veplayer';
-import RowItem from '@/components/RowItem';
-import {GlobalStyles} from '@/style';
-
-const viewId = 'my-view';
-
-const auth = {
-  appId: 'Your RTC AppID',
-  roomId: 'Your Room ID',
-  userId: 'Your User ID',
-  token: 'Your RTC Token',
-};
-
-const Page = () => {
-  const [isViewLoaded, setViewLoaded] = useState<boolean>(false);
-  const [filepath, setFilepath] = useState('');
-  const hasCaptureRef = useRef(false);
-  const playerRef = useRef<TTVideoEngine>();
-
-  const handleViewLoad = () => {
-    setViewLoaded(true);
-  };
-
-  const handleSelectVideoFile = async () => {
-    try {
-      const callback = (response: ImagePickerResponse) => {
-        if (!response.didCancel && !response.errorCode) {
-          const filePath = response.assets?.[0]?.uri;
-          if (filePath) {
-            setFilepath(filePath);
-          }
-        }
-      };
-      launchImageLibrary(
-        {
-          mediaType: 'video',
-        },
-        callback,
-      );
-    } catch {
-      Toast.fail('Select media file failed.');
-    }
-  };
-
-  const handlePublish = () => {
-    RTCClient.publishScreen(MediaStreamType.RTC_MEDIA_STREAM_TYPE_BOTH);
-  };
-
-  const setVideoSource = () => {
-    const source = filepath
-      ? createDirectUrlSource({
-          url: filepath,
-          cacheKey: filepath,
-        })
-      : createDirectUrlSource({
-          url: 'Your media url, like https://xxxx.mp4',
-          cacheKey: 'remote',
-          vid: 'remote',
-        });
-    playerRef.current!.setVideoSource(source);
-  };
-
-  const handlePlay = async () => {
-    if (hasCaptureRef.current) {
-      playerRef.current!.play();
-      return;
-    }
-    if (!playerRef.current) {
-      return;
-    }
-    setVideoSource();
-    await RTCClient.startVodPlayerCapture(playerRef.current);
-    await playerRef.current!.play();
-
-    RTCClient.publishScreen(MediaStreamType.RTC_MEDIA_STREAM_TYPE_BOTH);
-    
-    hasCaptureRef.current = true;
-  };
-
-  const handleStop = async () => {
-    if (hasCaptureRef.current) {
-      playerRef.current!.pause();
-    }
-  }
-
-  const handleDestroy = async () => {
-    if (!playerRef.current) {
-      return;
-    }
-    await RTCClient.stopVodPlayerCapture(playerRef.current);
-    hasCaptureRef.current = false;
-  }
-
-  const initializePlayer = async () => {
-    /**
-     * @brief It's not necessary to set viewId for vod player.
-     * @note You should realize veplayer for youself, refer to @byteplus/react-native-vod-player SDK.
-     */
-    playerRef.current = await createVeplayer({ viewId: '' });
-    playerRef.current.setListener({
-      onLoadStateChanged(engine, loadState) {
-        console.log('onLoadStateChanged: ', loadState);
-      },
-      onError(message, code) {
-        console.error('onError: ', message, code);
-      },
-      onPlaybackStateChanged(engine, playbackState) {
-        console.log('onPlaybackStateChanged: ', playbackState);
-      },
-    });
-  };
-
-  const initializeRTC = async () => {
-    /** Init your engine */
-    let DefaultPath = fs.ExternalDirectoryPath;
-    if (Platform.OS === 'ios') {
-      DefaultPath = fs.DocumentDirectoryPath;
-    }
-
-    /** Set log */
-    RTCClient.setLogConfig({
-      logLevel: LocalLogLevel.INFO,
-      logPath: DefaultPath,
-      logFileSize: 10,
-      logFilenamePrefix: '',
-    });
-
-    /** Create RTC Engine */
-    await RTCClient.createEngine({
-      appID: auth.appId,
-      parameters: {},
-    });
-
-    /** Set Local video canvas for player */
-    RTCClient.setLocalVideoCanvas(StreamIndex.STREAM_INDEX_SCREEN, {
-      viewId,
-      renderMode: RenderMode.ByteRTCRenderModeFit,
-    });
-
-    /** Join room */
-    RTCClient.createRoom(auth.roomId);
-    RTCClient.setRTCRoomEventHandler({
-      onUserJoined(userInfo, elapsed) {
-        console.log('onUserJoined: ', userInfo, elapsed);
-      },
-    });
-    RTCClient.joinRoom({
-      token: auth.token,
-      userId: auth.userId,
-      roomConfigs: {
-        profile: 0,
-        isAutoPublish: true,
-        isAutoSubscribeAudio: false,
-        isAutoSubscribeVideo: false,
-      },
-    });
-  };
-
-  useEffect(() => {
-    if (isViewLoaded) {
-      initializeRTC();
-      initializePlayer();
-      console.log('init success');
-    }
-  }, [isViewLoaded]);
-
-  useEffect(() => {
-    return () => {
-      RTCClient.engine?.stopVodPlayerCapture(playerRef.current);
-    }
-  }, []);
-
-  return (
-    <SafeAreaView>
-      <ScrollView
-        style={{
-          display: 'flex',
-          flexDirection: 'column',
-          width: '100%',
-          height: '100%',
-          backgroundColor: 'gray',
-        }}>
-        <RowItem
-          theme="dark"
-          leftItem="File path"
-          leftItemStyle={{width: '25%'}}
-          rightItem={
-            <Input disabled placeholder="Select media file" value={filepath} />
-          }
-        />
-        <Button
-          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
-          onPress={handleSelectVideoFile}>
-          <Text style={{color: 'gray'}}>Select media file</Text>
-        </Button>
-        <Button
-          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
-          onPress={() => setFilepath('')}>
-          <Text style={{color: 'gray'}}>Clear media file</Text>
-        </Button>
-        <Button
-          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
-          onPress={handlePublish}>
-          <Text style={{color: 'gray'}}>Push Stream</Text>
-        </Button>
-        <Button
-          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
-          onPress={handlePlay}>
-          <Text style={{color: 'gray'}}>Play</Text>
-        </Button>
-        <Button
-          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
-          onPress={handleStop}>
-          <Text style={{color: 'gray'}}>Pause</Text>
-        </Button>
-        <Button
-          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
-          onPress={handleDestroy}>
-          <Text style={{color: 'gray'}}>Destroy</Text>
-        </Button>
-        <View
-          style={{
-            flex: 1,
-            width: '100%',
-            minHeight: 300,
-            backgroundColor: '#000',
-          }}>
-          <Text>{`${viewId}`}</Text>
-          <NativeViewComponent
-            viewId={viewId}
-            style={{
-              width: '100%',
-              height: '100%',
-            }}
-            onLoad={handleViewLoad}
-            kind={
-              Platform.select({
-                android: 'SurfaceView',
-                ios: 'UIView',
-              })!
-            }
-          />
-        </View>
-      </ScrollView>
-    </SafeAreaView>
-  );
-};
-
-export default Page;
-```
-
-
 ## Attention
 - In Android/iOS scenarios, the screen sharing method is slightly different. For details, please refer to [Android screen sharing](https://docs.byteplus.com/en/docs/byteplus-rtc/docs-124176) and [iOS screen sharing](https://docs.byteplus.com/en/docs/byteplus-rtc/docs-124177).
 - Not support debug in iOS simulator, using real device instead.

package/android/build.gradle

@@ -9,6 +9,35 @@ buildscript {
   }
 }
 
+def getLicenseType() {
+  try {
+    def packageJson = file("../../../../package.json")
+    def parsedJson = new groovy.json.JsonSlurper().parseText(packageJson.text)
+    return parsedJson.TTVideoEngine.licenseType
+  } catch (e) {
+    return "premium"
+  }
+}
+
+def enableUnionForRTCWithLive = project.findProperty('enableUnionForRTCWithLive') == null ? false : project.findProperty('enableUnionForRTCWithLive').toString().toBoolean()
+def enableUnionForRTCWithVod = project.findProperty('enableUnionForRTCWithVod') == null ? false : project.findProperty('enableUnionForRTCWithVod').toString().toBoolean()
+
+def packageJson = file("../package.json")
+def parsedJson = new groovy.json.JsonSlurper().parseText(packageJson.text)
+def isBp = parsedJson.name.startsWith("@byteplus")
+
+def license_type = getLicenseType()
+
+def rtcVersionToUse
+if (isBp) {
+  rtcVersionToUse = enableUnionForRTCWithLive ? "3.58.1.20600" : "3.58.1.15100"
+  println "Using BytePlusRTC SDK version : $rtcVersionToUse (union live enabled: $enableUnionForRTCWithLive / union vod enabled: $enableUnionForRTCWithVod)"
+} else {
+  rtcVersionToUse = enableUnionForRTCWithLive ? "3.58.1.20700" : "3.58.1.2700"
+  println "Using VolcEngineRTC SDK version : $rtcVersionToUse (union build enabled: $enableUnionForRTCWithLive / union vod enabled: $enableUnionForRTCWithVod)"
+}
+
+
 def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
@@ -36,42 +65,16 @@ def supportsNamespace() {
   return (major == 7 && minor >= 3) || major >= 8
 }
 
-def getLicenseType() {
-  try {
-    def packageJson = file("../../../../package.json")
-    def parsedJson = new groovy.json.JsonSlurper().parseText(packageJson.text)
-    return parsedJson.TTVideoEngine.licenseType
-  } catch (e) {
-    return "premium"
-  }
-}
-
-def getNativeDep() {
-  def packageJson = file("../package.json")
-  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"
-    println "Using BytePlusRTC SDK version : $rtcVersionToUse (union build enabled: $enableUnionForRTCWithLive)"
-    return "com.byteplus:BytePlusRTC:$rtcVersionToUse"
+android {
+  sourceSets {
+    main {
+      java.srcDirs = ['src/main/java']
+      manifest.srcFile "src/main/AndroidManifestNew.xml"
+    }
   }
-  rtcVersionToUse = enableUnionForRTCWithLive ? "3.58.1.20700" : "3.58.1.2700"
-  println "Using VolcEngineRTC SDK version : $rtcVersionToUse (union build enabled: $enableUnionForRTCWithLive)"
-  return "com.volcengine:VolcEngineRTC:$rtcVersionToUse"
-}
 
-android {
   if (supportsNamespace()) {
     namespace "com.volcengine.reactnative.vertc"
-
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
   }
 
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
@@ -99,23 +102,35 @@ android {
   }
 }
 
+def apiVolcEngineVersion = "1.6.2";
+
+if (enableUnionForRTCWithLive) {
+  android.sourceSets.main.java.srcDirs += 'src/live/java'
+  dependencies {
+    implementation project(':byteplus_react-native-live-push')
+    implementation "com.bytedanceapi:ttsdk-player_$license_type:1.46.300.2"
+  }
+}
+
+if (enableUnionForRTCWithVod) {
+  android.sourceSets.main.java.srcDirs += 'src/vod/java'
+  // 
+  // Might cause rtc api some error, just alpha version.
+  // 
+  apiVolcEngineVersion = '1.5.0'
+  dependencies {
+    implementation "com.bytedanceapi:ttsdk-player_$license_type:1.46.300.2"
+  }
+}
+
 dependencies {
   // For < 0.71, this will be from the local maven repo
   // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
   // noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
 
-  implementation "com.volcengine:VolcApiEngine:1.6.2"
-//   implementation project(":hybrid-runtime");
+  implementation "com.volcengine:VolcApiEngine:$apiVolcEngineVersion"
 
   // Use the RTC SDK dependency determined by getNativeDep() which can be overridden by customer's app build.gradle.
-  def rtcDep = getNativeDep()
-  implementation rtcDep
-
-  // TTVideoEngine
-  // byteplus and volcengine use different name, different version
-  // volcengine     com.bytedanceapi:ttsdk-player_premium:1.43.1.5      com.bytedanceapi:ttsdk-player_standard:1.43.1.5
-  // 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.+"
+  implementation isBp ? "com.byteplus:BytePlusRTC:$rtcVersionToUse" : "com.volcengine:VolcEngineRTC:$rtcVersionToUse"
 }

package/android/src/live/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/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/ios/core/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