@byteplus/react-native-rtc 1.0.5 → 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

@@ -7,18 +7,31 @@ 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() {
-    Log.d("VertcHelper", "channelSolutions" + sInstance);
     return sInstance;
   }
   
   public int invokeSetVideoEncoderConfig(RTCVideo engine, VideoEncoderConfig[] channelSolutions) {
-    Log.d("VertcHelper", "channelSolutions");
     return engine.setVideoEncoderConfig(channelSolutions);
   }
+
+  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