@byteplus/react-native-live-pull 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright 2024 Beijing Volcano Engine Technology Co., Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# 火山引擎直播拉流 React Native SDK
+

package/android/build.gradle

@@ -0,0 +1,93 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply from: "https://ve-vos.volccdn.com/script/vevos-repo-base.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["LivePull_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["LivePull_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.volcengine.velive.rn.pull"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    consumerProguardFiles 'proguard-rules.pro' 
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+  maven {
+    url "https://artifact.bytedance.com/repository/Volcengine/" // volc public maven repo
+  }
+}
+
+
+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.0.1"
+    implementation 'com.bytedanceapi:ttsdk-ttlivepull_rtc:1.41.3.4'
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+LivePull_kotlinVersion=1.7.0
+LivePull_minSdkVersion=21
+LivePull_targetSdkVersion=31
+LivePull_compileSdkVersion=31
+LivePull_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="com.volcengine.velive.rn.pull">
+
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+
+</manifest>

package/android/src/main/java/com/volcengine/velive/rn/pull/NativeVariableManager.java

@@ -0,0 +1,15 @@
+package com.volcengine.velive.rn.pull;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.volcengine.VolcApiEngine.runtime.*;
+
+public class NativeVariableManager {
+  static void init(@NonNull MessageClient msgClient, ReactApplicationContext reactContext) {
+    var m = msgClient.proto.variableManager;
+
+    m.registerVar("ApplicationContext", (Object[] args) -> reactContext.getApplicationContext());
+    m.registerVar("ReactApplicationContext", (Object[] args) -> reactContext);
+  }
+}

package/android/src/main/java/com/volcengine/velive/rn/pull/VolcLiveModule.java

@@ -0,0 +1,108 @@
+package com.volcengine.velive.rn.pull;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import com.volcengine.VolcApiEngine.runtime.*;
+import com.volcengine.velive.rn.pull.autogen.MethodSignature;
+
+@ReactModule(name = VolcLiveModule.NAME)
+public class VolcLiveModule extends VolcLiveModuleSpec implements IEventReceiver {
+  public static final String NAME = "VolcLiveModule";
+  
+  VolcApiEngine apiEngine = null;
+  
+  VolcLiveModule(ReactApplicationContext context) {
+    super(context);
+    MethodSignature.init();
+  }
+  
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean newApiEngine() {
+    if (apiEngine == null) {
+      apiEngine = new VolcApiEngine(super.context, this);
+      NativeVariableManager.init(apiEngine.msgClient, super.context);
+      return true;
+    }
+    
+    return false;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String callApiSync(ReadableMap arg)  {
+    try {
+      newApiEngine();
+      String params = arg.getString("params");
+      return this.apiEngine.callApi(params);
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw new RuntimeException(e);
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = false)
+  public void callApi(ReadableMap arg, Callback callback)  {
+    try {
+      newApiEngine();
+      String params = arg.getString("params");
+      this.apiEngine.callApi(params, (res) -> {
+        callback.invoke(res.toJsonString());
+      }); 
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw new RuntimeException(e);
+    }
+  }
+
+  private int listenerCount = 0;
+
+  @ReactMethod
+  public void addListener(String eventName) {
+    if (listenerCount == 0) {
+      // Set up any upstream listeners or background tasks as necessary
+    }
+
+    listenerCount += 1;
+  }
+
+  @ReactMethod
+  public void removeListeners(Integer count) {
+    listenerCount -= count;
+    if (listenerCount == 0) {
+      // Remove upstream listeners, stop unnecessary background tasks
+    }
+  }
+
+  private void sendEvent(ReactContext reactContext,
+                          String eventName,
+                          @Nullable WritableMap params) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit(eventName, params);
+  }
+
+  @Override
+  public void OnEvent(String event, String data) {
+    final WritableMap map = Arguments.createMap();
+    map.putString("event", event);
+    map.putString("data", data);
+
+    super.context
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit(VolcLiveModuleSpec.EVENT, map);
+  }
+}

package/android/src/main/java/com/volcengine/velive/rn/pull/VolcLiveModuleSpec.java

@@ -0,0 +1,17 @@
+package com.volcengine.velive.rn.pull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+
+public abstract class VolcLiveModuleSpec extends ReactContextBaseJavaModule {
+  static final String EVENT = "VolcLive:onEvent";
+  
+  VolcLiveModuleSpec(ReactApplicationContext context) {
+    super(context);
+    this.context = context;
+  }
+  
+  public  ReactApplicationContext context;
+
+  public abstract void OnEvent(String eventName, String data);
+}

package/android/src/main/java/com/volcengine/velive/rn/pull/VolcLivePackage.java

@@ -0,0 +1,27 @@
+package com.volcengine.velive.rn.pull;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class VolcLivePackage implements ReactPackage {
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+      List<ViewManager> viewManagers = new ArrayList<>();
+      viewManagers.add(new VolcViewManager());
+      return viewManagers;
+    }
+
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new VolcLiveModule(reactContext));
+        return modules;
+    }
+}

package/android/src/main/java/com/volcengine/velive/rn/pull/VolcView.java

@@ -0,0 +1,32 @@
+package com.volcengine.velive.rn.pull;
+
+import android.content.Context;
+import android.widget.FrameLayout;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+public class VolcView extends FrameLayout {
+  public String viewId;
+  public boolean hasRegister = false;
+  
+  public VolcView(Context context) {
+    super(context);
+  }
+  
+  public void setViewId(String viewId) {
+    this.viewId = viewId;  
+    this.hasRegister = true;
+    this.emitOnLoad();
+  }
+
+  public void emitOnLoad() {
+    WritableMap event = Arguments.createMap();
+    ReactContext reactContext = (ReactContext)getContext();
+    reactContext
+      .getJSModule(RCTEventEmitter.class)
+      .receiveEvent(getId(), "load", event);
+  }
+}

package/android/src/main/java/com/volcengine/velive/rn/pull/VolcViewManager.java

@@ -0,0 +1,87 @@
+package com.volcengine.velive.rn.pull;
+
+import android.view.SurfaceView;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.volcengine.VolcApiEngine.view.*;
+
+import java.util.Map;
+
+public class VolcViewManager extends SimpleViewManager<VolcView> implements VolcViewManagerInterface<VolcView> {
+  public static final String NAME = "VolcView";
+  
+  private ThemedReactContext context;
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @NonNull
+  @Override
+  public VolcView createViewInstance(@NonNull ThemedReactContext themedReactContext) {
+    context = themedReactContext;
+    return new VolcView(themedReactContext);
+  }
+  
+  @ReactProp(name = "viewId")
+  public void setViewId(VolcView view, String viewId) {
+    view.setViewId(viewId);
+    com.volcengine.VolcApiEngine.view.VolcViewManager.putViewById(viewId, view);
+  }
+
+  @ReactProp(name = "kind")
+  public void setKind(VolcView view, String kind) {
+    var themedReactContext = this.context;
+    
+    switch (kind) {
+      case "SurfaceView" -> {
+        SurfaceView subView = new SurfaceView(themedReactContext.getReactApplicationContext());
+        view.addView(subView);
+      }
+    }
+  }
+  
+  public void setVisible(VolcView view, Boolean visible) {
+    if(visible) {
+      view.setVisibility(View.INVISIBLE);
+    } else {
+      view.setVisibility(View.VISIBLE);
+    }
+  }
+
+  /**
+   * Handle "create" command (called from JS) and call createFragment method
+   */
+  public void receiveCommand(
+    @NonNull VolcView root,
+    String command,
+    @Nullable ReadableArray args
+  ) {
+    super.receiveCommand(root, command, args);
+
+    if (command.equals("setVisible")) {
+      assert args != null;
+      setVisible(root, args.getBoolean(0));
+    }
+  }
+
+  public Map getExportedCustomBubblingEventTypeConstants() {
+    return MapBuilder.builder().put(
+      "load",
+      MapBuilder.of(
+        "phasedRegistrationNames",
+        MapBuilder.of("bubbled", "onLoad")
+      )
+    ).build();
+  }
+}

package/android/src/main/java/com/volcengine/velive/rn/pull/autogen/MethodSignature.java

@@ -0,0 +1,129 @@
+package com.volcengine.velive.rn.pull.autogen;
+
+import static com.volcengine.VolcApiEngine.runtime.MethodSignature.*;
+
+import android.view.Surface;
+import android.view.SurfaceHolder;
+
+import com.ss.videoarch.liveplayer.VeLivePlayer;
+import com.ss.videoarch.liveplayer.VeLivePlayerConfiguration;
+import com.ss.videoarch.liveplayer.VeLivePlayerDef;
+import com.ss.videoarch.liveplayer.VeLivePlayerObserver;
+import com.ss.videoarch.liveplayer.VeLivePlayerStreamData;
+import com.ss.videoarch.liveplayer.log.VeLivePlayerLogConfig;
+
+import java.util.Map;
+
+public class MethodSignature {
+  static public void init() {
+    try {
+      var r = createClassMethodRegister("com.ss.videoarch.liveplayer.VideoLiveManager");
+
+      r.put(
+        "setConfig",
+        VeLivePlayer.class.getMethod("setConfig", VeLivePlayerConfiguration.class));
+
+      r.put(
+        "setObserver",
+        VeLivePlayer.class.getMethod("setObserver", VeLivePlayerObserver.class));
+
+      r.put("setRenderFillMode",
+        VeLivePlayer.class.getMethod("setRenderFillMode", VeLivePlayerDef.VeLivePlayerFillMode.class));
+      
+      r.put("getVersion", VeLivePlayer.class.getMethod("getVersion"));
+      
+      r.put(
+        "setSurfaceHolder",
+        VeLivePlayer.class.getMethod("setSurfaceHolder", SurfaceHolder.class));
+      
+      r.put("setSurface", 
+        VeLivePlayer.class.getMethod("setSurface", Surface.class));
+
+      r.put(
+        "setPlayUrl",
+        VeLivePlayer.class.getMethod("setPlayUrl", String.class));
+      
+      r.put(
+        "setLogLevel",   
+        VeLivePlayer.class.getMethod("setLogLevel", VeLivePlayerLogConfig.VeLivePlayerLogLevel.class));
+
+      r.put(
+        "setLogConfig",
+        VeLivePlayer.class.getMethod("setLogConfig", VeLivePlayerLogConfig.class));
+
+      r.put("setPlayStreamData",
+        VeLivePlayer.class.getMethod("setPlayStreamData", VeLivePlayerStreamData.class));
+      
+      r.put(
+        "play",
+        VeLivePlayer.class.getMethod("play"));
+      r.put(
+        "pause",
+        VeLivePlayer.class.getMethod("pause"));
+
+      r.put(
+        "stop",
+        VeLivePlayer.class.getMethod("stop"));
+
+      r.put("destroy", VeLivePlayer.class.getMethod("destroy"));
+
+      r.put(
+        "switchResolution",
+        VeLivePlayer.class.getMethod("switchResolution", VeLivePlayerDef.VeLivePlayerResolution.class));
+
+      r.put("isPlaying", VeLivePlayer.class.getMethod("isPlaying"));
+
+      r.put(
+        "setPlayerVolume",
+        VeLivePlayer.class.getMethod("setPlayerVolume", float.class));
+      
+      r.put("setMute", VeLivePlayer.class.getMethod("setMute", boolean.class));
+
+      r.put("isMute", VeLivePlayer.class.getMethod("isMute"));
+      
+      r.put(
+        "setUrlHostIP",
+        VeLivePlayer.class.getMethod("setUrlHostIP", Map.class));
+
+      r.put(
+        "setGlobalUrlHostIP",
+        VeLivePlayer.class.getMethod("setGlobalUrlHostIP", Map.class));
+
+      r.put(
+        "setProperty",
+        VeLivePlayer.class.getMethod("setProperty", String.class, Object.class));
+
+      r.put(
+        "snapshot",
+        VeLivePlayer.class.getMethod("snapshot"));
+
+      r.put(
+        "enableVideoFrameObserver",
+        VeLivePlayer.class.getMethod(
+          "enableVideoFrameObserver",
+          boolean.class, VeLivePlayerDef.VeLivePlayerPixelFormat.class, VeLivePlayerDef.VeLivePlayerVideoBufferType.class));
+
+      r.put(
+        "enableAudioFrameObserver",
+        VeLivePlayer.class.getMethod(
+          "enableAudioFrameObserver", 
+          boolean.class, boolean.class));
+      
+      r.put(
+        "setRenderRotation",
+        VeLivePlayer.class.getMethod("setRenderRotation", VeLivePlayerDef.VeLivePlayerRotation.class));
+
+      r.put(
+        "setRenderMirror",
+        VeLivePlayer.class.getMethod("setRenderMirror", VeLivePlayerDef.VeLivePlayerMirror.class));
+      
+
+      r.put("setEnableSuperResolution", VeLivePlayer.class.getMethod("setEnableSuperResolution", boolean.class));
+
+      r.put("setEnableSharpen", VeLivePlayer.class.getMethod("setEnableSharpen", boolean.class));
+
+    } catch (NoSuchMethodException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}

package/ios/VeLivePullSDK.h

@@ -0,0 +1,24 @@
+//
+//  VeLivePullSDK.h
+//  rn
+//
+//  Created by ByteDance on 2024/4/10.
+//
+
+#ifndef VeLivePullSDK_h
+#define VeLivePullSDK_h
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import "VolcApiEngine/Engine.h"
+
+@interface RCTVolcLiveModule : RCTEventEmitter <RCTBridgeModule>
+
+@property(nonatomic, strong) VolcApiEngine *volcApiEngine;
+
++ (instancetype)shareInstance;
+
+@end
+
+#endif /* VeLivePullSDK_h */

package/ios/VeLivePullSDK.m

@@ -0,0 +1,91 @@
+//
+//  VeLivePullSDK.m
+//  rn
+//
+//  Created by ByteDance on 2024/4/10.
+//
+
+#import <UIKit/UIKit.h>
+#import <Foundation/Foundation.h>
+
+#import <TTSDKFramework/TTSDKFramework.h>
+
+#import "VolcApiEngine/VolcEventObserver.h"
+#import "VeLivePullSDK.h"
+
+#define EVENT_NAME @"VolcLive:onEvent"
+
+@interface RCTVolcLiveModule () <EventObserver>
+
+@end
+
+static RCTVolcLiveModule *instance = nil;
+
+@implementation RCTVolcLiveModule
+{
+  bool hasListeners;
+}
+
++ (instancetype)shareInstance {
+    return instance;
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
++ (void)_unsedForKeepOnly {
+    Protocol *unused = @protocol(VeLivePlayerObserver);
+    NSLog(@"Loaded Protocol: %p", unused);
+}
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self != nil) {
+        self.volcApiEngine = nil;
+        instance = self;
+    }
+    return instance;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[ EVENT_NAME ];
+}
+
+- (void)onEvent:(NSString *)eventName data:(id)eventData
+{
+  NSDictionary * dic = @{ @"event": eventName, @"data": eventData };
+  [self sendEventWithName:EVENT_NAME body:dic];
+}
+
+RCT_EXPORT_MODULE();
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(newApiEngine)
+{
+  if (self.volcApiEngine == nil) {
+    self.volcApiEngine = [[VolcApiEngine alloc] init];
+    [self.volcApiEngine setObserver:self];
+  }
+  return nil;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(callApiSync:(nonnull NSDictionary *) args)
+{
+  [self newApiEngine];
+  return [instance.volcApiEngine callApi:args];
+}
+
+RCT_EXPORT_METHOD(callApi:(nonnull NSDictionary *)args callback:(RCTResponseSenderBlock) callback)
+{
+  [self newApiEngine];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    id _val = [self.volcApiEngine callApi:args];
+    callback(@[_val]);
+  });
+}
+
+@end