@byteplus/react-native-live-push 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,92 @@
+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.push"
+
+    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-ttlivepush_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,16 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="com.volcengine.velive.rn.push">
+
+  <uses-permission android:name="android.permission.CAMERA" />
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.RECEIVE_USER_PRESENT" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+  <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+  <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,16 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <uses-permission android:name="android.permission.CAMERA" />
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.RECEIVE_USER_PRESENT" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+  <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+  <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
+
+</manifest>

package/android/src/main/java/com/volcengine/velive/rn/push/ExternalSourceHelper.java

@@ -0,0 +1,58 @@
+package com.volcengine.velive.rn.push;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.ss.avframework.live.VeLiveAudioFrame;
+import com.ss.avframework.live.VeLivePusher;
+
+import java.util.HashMap;
+
+public class ExternalSourceHelper {
+  interface IExternalFrameTask {
+     void onStart(VeLivePusher pusher, ReadableMap info);
+     void onStop();
+  }
+  
+  static HashMap<Integer, ExternalFrameTask> Tasks = new HashMap<>();
+  
+  static class ExternalFrameTask {
+    static public int TASK_ID = 1;
+    
+    private final IExternalFrameTask impl;
+    private final VeLivePusher pusher;
+    private final ReadableMap arg;
+    public final int taskId;
+
+    ExternalFrameTask(IExternalFrameTask impl, VeLivePusher pusher, int fps, ReadableMap arg) {
+      this.impl = impl;
+      this.pusher = pusher;
+      this.arg = arg;
+      this.taskId = TASK_ID++;
+      
+      Tasks.put(taskId, this);
+    }
+
+    public void start() {
+      this.impl.onStart(pusher, arg);
+    }
+
+    public void stop() {
+      this.impl.onStop();
+    }
+  }
+  
+  public ExternalFrameTask startPushExternalVideoFrame(VeLivePusher pusher, String implClassName, ReadableMap arg) {
+    try {
+      Class<?> clazz = Class.forName(implClassName);
+      Object impl = clazz.newInstance();
+      var t = new ExternalFrameTask((IExternalFrameTask) impl, pusher, 30, arg);
+      t.start();
+      return t;
+    } catch (ClassNotFoundException e) {
+      throw new RuntimeException("unknown class " + implClassName);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException("class " + implClassName + " should impl IExternalFrameTask");
+    } catch (InstantiationException e) {
+      throw new RuntimeException("class " + implClassName + " should new with empty args");
+    } 
+  }
+}

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

@@ -0,0 +1,19 @@
+package com.volcengine.velive.rn.push;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.volcengine.VolcApiEngine.runtime.*;
+
+public class NativeVariableManager {
+  static void init(@NonNull VolcApiEngine apiEngine, ReactApplicationContext reactContext) {
+    var m = apiEngine.msgClient.proto.variableManager;
+    
+    m.registerVar("ApplicationContext", (Object[] args) -> reactContext.getApplicationContext());
+    m.registerVar("ReactApplicationContext", (Object[] args) -> reactContext);
+
+    var helper = new ScreenCaptureHelper(reactContext);
+    m.registerVar("screenIntent", helper::getScreenIntent);
+    helper.setup();
+  }
+}

package/android/src/main/java/com/volcengine/velive/rn/push/ScreenCaptureHelper.java

@@ -0,0 +1,73 @@
+package com.volcengine.velive.rn.push;
+
+import static android.content.Context.MEDIA_PROJECTION_SERVICE;
+
+import static com.volcengine.VolcApiEngine.runtime.NativeVariableManager.*;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.media.projection.MediaProjectionManager;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
+
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+
+public class ScreenCaptureHelper {
+  static final int SCREEN_RECORD_REQUEST_CODE = 1010;
+  
+  private final ReactApplicationContext reactApplicationContext;
+  
+  private AsyncVariableGetterCallback<Intent> mCallback;
+
+  ScreenCaptureHelper(ReactApplicationContext reactApplicationContext) {
+    this.reactApplicationContext = reactApplicationContext;
+  }
+
+  ReactApplicationContext getReactApplicationContext() {
+    return this.reactApplicationContext;
+  }
+  
+  public void setup() {
+    getReactApplicationContext().addActivityEventListener(new ActivityEventListener() {
+      @Override
+      public void onActivityResult(Activity activity, int requestCode, int resultCode, @Nullable Intent intent) {
+        if (requestCode != SCREEN_RECORD_REQUEST_CODE) {
+          return;
+        }
+
+        // success
+        if (resultCode == AppCompatActivity.RESULT_OK) {
+          if (mCallback != null) {
+            mCallback.resolve(null, intent);
+            mCallback = null;
+          }
+          return;
+        } 
+        
+        // error        
+        if (mCallback != null) {
+          mCallback.resolve(new Exception("permission error"), null);
+          mCallback = null;
+        }
+      }
+
+      @Override
+      public void onNewIntent(Intent intent) {
+      }
+    });
+  }
+
+  public void getScreenIntent(Object[] args, @NonNull AsyncVariableGetterCallback cb) {
+    this.mCallback = cb;
+    this.requestPermission();
+  }
+  
+  private void requestPermission() {
+    MediaProjectionManager mediaProjectionManager = (MediaProjectionManager) getReactApplicationContext().getSystemService(MEDIA_PROJECTION_SERVICE);
+    Intent permissionIntent =  mediaProjectionManager.createScreenCaptureIntent();
+    getReactApplicationContext().getCurrentActivity().startActivityForResult(permissionIntent, SCREEN_RECORD_REQUEST_CODE);
+  }
+}

package/android/src/main/java/com/volcengine/velive/rn/push/VeLivePushModule.java

@@ -0,0 +1,182 @@
+package com.volcengine.velive.rn.push;
+
+import static com.volcengine.VolcApiEngine.runtime.Util.JsonAbleClass;
+
+import android.util.Log;
+
+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.modules.core.DeviceEventManagerModule;
+
+import com.ss.avframework.live.VeLivePusherConfiguration;
+import com.ss.avframework.live.VeLivePusherDef;
+import com.ss.avframework.live.VeLivePusherObserver;
+import com.volcengine.VolcApiEngine.runtime.*;
+import com.volcengine.VolcApiEngine.view.*;
+
+public class VeLivePushModule extends VeLivePushModuleSpec implements IEventReceiver {
+  static  {
+    JsonAbleClass.add(VeLivePusherDef.VeLivePusherStatistics.class);
+  }
+  
+  VolcApiEngine apiEngine = null;
+
+  VeLivePushModule(ReactApplicationContext context) {
+    super(context);
+  }
+  
+  @Override
+  public String getName() {
+    return "VeLivePushModule";
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean newApiEngine() {
+    if (apiEngine == null) {
+      apiEngine = new VolcApiEngine(getReactApplicationContext(), this);
+
+      NativeVariableManager.init(apiEngine, super.context);
+      return true;
+    }
+
+    return false;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean destroyApiEngine() {
+    if (apiEngine != null) {
+       apiEngine.msgClient.proto.dispose(); 
+       apiEngine = null;
+    }
+    return true;
+  }
+
+  @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);
+
+    getReactApplicationContext()
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit(VeLivePushModuleSpec.EVENT, map);
+  }
+  
+  @ReactMethod(isBlockingSynchronousMethod = false)
+  public void test() {
+    VeLivePusherConfiguration config = new VeLivePusherConfiguration();
+    config.setContext(this.getReactApplicationContext());
+    config.setReconnectCount(10);
+
+    var mLivePusher = config.build();
+    mLivePusher.setObserver(new VeLivePusherObserver() {
+      @Override
+      public void onAudioPowerQuality(VeLivePusherDef.VeLiveAudioPowerLevel level, float value) {
+        Log.d("VeLivePusherObserver", "onAudioPowerQuality");
+      }
+
+      @Override
+      public void onNetworkQuality(VeLivePusherDef.VeLiveNetworkQuality quality) {
+        Log.d("VeLivePusherObserver", "onNetworkQuality");
+      }
+
+      @Override
+      public void onScreenRecording(boolean open) {
+        Log.d("VeLivePusherObserver", "onScreenRecording");
+      }
+
+      @Override
+      public void onMicrophoneOpened(boolean open) {
+        Log.d("VeLivePusherObserver", "onMicrophoneOpened");
+      }
+
+      @Override
+      public void onCameraOpened(boolean open) {
+        Log.d("VeLivePusherObserver", "onCameraOpened");
+      }
+
+      @Override
+      public void onFirstAudioFrame(VeLivePusherDef.VeLiveFirstFrameType type, long timestampMs) {
+        Log.d("VeLivePusherObserver", "onFirstAudioFrame");
+      }
+
+      @Override
+      public void onFirstVideoFrame(VeLivePusherDef.VeLiveFirstFrameType type, long timestampMs) {
+        Log.d("VeLivePusherObserver", "onFirstVideoFrame");
+      }
+
+      @Override
+      public void onStatusChange(VeLivePusherDef.VeLivePusherStatus status) {
+        Log.d("VeLivePusherObserver", "onStatusChange");
+      }
+
+      @Override
+      public void onError(int code, int subCode, String msg) {
+        Log.d("VeLivePusherObserver", "onError");
+      }
+    });
+    
+    mLivePusher.setRenderView(VolcViewManager.getViewById("live-pusher"));
+    mLivePusher.startVideoCapture(VeLivePusherDef.VeLiveVideoCaptureType.VeLiveVideoCaptureFrontCamera);
+  }
+}

package/android/src/main/java/com/volcengine/velive/rn/push/VeLivePushModuleSpec.java

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

package/android/src/main/java/com/volcengine/velive/rn/push/VeLivePushPackage.java

@@ -0,0 +1,27 @@
+package com.volcengine.velive.rn.push;
+
+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 VeLivePushPackage implements ReactPackage {
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+      List<ViewManager> viewManagers = new ArrayList<>();
+      viewManagers.add(new VeLivePushViewManager());
+      return viewManagers;
+    }
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+
+        modules.add(new VeLivePushModule(reactContext));
+
+        return modules;
+    }
+}

package/android/src/main/java/com/volcengine/velive/rn/push/VeLivePushView.java

@@ -0,0 +1,45 @@
+package com.volcengine.velive.rn.push;
+
+import android.content.Context;
+import android.util.Log;
+import android.view.SurfaceView;
+import android.view.View;
+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 VeLivePushView extends FrameLayout {
+  public String viewId;
+  public boolean hasRegister = false;
+  
+  public VeLivePushView(Context context) {
+    super(context);
+  }
+  
+  public void setViewId(String viewId) {
+    this.viewId = viewId;  
+    this.hasRegister = true;
+    this.emitOnLoad();
+  }
+  
+  public void setVisible(Boolean visible) {
+    Log.i("surfaceView", "setVisible");
+    View subview = this.getChildAt(0);
+    if(visible) {
+      subview.setVisibility(View.VISIBLE);
+    } else {
+      subview.setVisibility(View.INVISIBLE);
+    }
+  }
+
+  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/push/VeLivePushViewManager.java

@@ -0,0 +1,87 @@
+package com.volcengine.velive.rn.push;
+
+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 VeLivePushViewManager extends SimpleViewManager<VeLivePushView> implements VolcViewManagerInterface<VeLivePushView> {
+  public static final String NAME = "VeLivePushView";
+  
+  private ThemedReactContext context;
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @NonNull
+  @Override
+  public VeLivePushView createViewInstance(@NonNull ThemedReactContext themedReactContext) {
+    context = themedReactContext;
+    return new VeLivePushView(themedReactContext);
+  }
+  
+  @ReactProp(name = "viewId")
+  public void setViewId(VeLivePushView view, String viewId) {
+    view.setViewId(viewId);
+    VolcViewManager.putViewById(viewId, view);
+  }
+
+  @ReactProp(name = "kind")
+  public void setKind(VeLivePushView view, String kind) {
+    var themedReactContext = this.context;
+    
+    switch (kind) {
+      case "SurfaceView" -> {
+        SurfaceView subView = new SurfaceView(themedReactContext.getReactApplicationContext());
+        view.addView(subView);
+      }
+      case "View" -> {
+        View subView = new View(themedReactContext.getApplicationContext());
+        view.addView(subView);
+      }
+    }
+  }
+  
+  public void setVisible(VeLivePushView view, Boolean visible) {
+    view.setVisible(visible);
+  }
+
+  /**
+   * Handle "create" command (called from JS) and call createFragment method
+   */
+  public void receiveCommand(
+    @NonNull VeLivePushView 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();
+  }
+}