@volcengine/react-native-live-push 1.1.3-rc.0 → 1.2.0-rc.0

package/android/build.gradle

@@ -87,6 +87,6 @@ dependencies {
   // 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.2.3"
-    api 'com.bytedanceapi:ttsdk-ttlivepush_rtc:1.41.3.4'
+    implementation "com.volcengine:VolcApiEngine:1.6.2"
+    api 'com.bytedanceapi:ttsdk-ttlivepush_rtc:1.46.3.6'
 }

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

@@ -0,0 +1,9 @@
+package com.volcengine.velive.rn.push;
+import com.ss.avframework.live.statistics.VeLivePusherStatisticsExt;
+import com.volcengine.VolcApiEngine.runtime.Util;
+
+public class ClassHelper {
+  public static void init() {
+    Util.JsonAbleClass.add(VeLivePusherStatisticsExt.class);
+  }
+}

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

@@ -1,19 +1,16 @@
 package com.volcengine.velive.rn.push;
 
 import androidx.annotation.NonNull;
-
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.volcengine.VolcApiEngine.*;
 
 public class NativeVariableManager {
-  static void init(@NonNull VolcApiEngine apiEngine, ReactApplicationContext reactContext) {
+  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();
+    m.registerVar("ApplicationContext",
+                  (Object[] args) -> reactContext.getApplicationContext());
+    m.registerVar("ReactApplicationContext", (Object[] args) -> reactContext);
   }
 }

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

@@ -50,6 +50,7 @@ public class VeLivePushModule extends VeLivePushModuleSpec implements IEventRece
       apiEngine = new VolcApiEngine(getReactApplicationContext(), this);
 
       NativeVariableManager.init(apiEngine, super.context);
+      ClassHelper.init();
       return true;
     }
 
@@ -82,8 +83,19 @@ public class VeLivePushModule extends VeLivePushModuleSpec implements IEventRece
     try {
       newApiEngine();
       String params = arg.getString("params");
-      this.apiEngine.callApi(params, (res) -> {
-        callback.invoke(res.toJsonString());
+
+      // 获取主线程处理器
+      android.os.Handler mainHandler =
+          new android.os.Handler(android.os.Looper.getMainLooper());
+
+      // 在主线程上执行 API 调用
+      mainHandler.post(() -> {
+        try {
+          this.apiEngine.callApi(
+              params, (res) -> { callback.invoke(res.toJsonString()); });
+        } catch (Exception e) {
+          e.printStackTrace();
+        }
       });
     } catch (Exception e) {
       e.printStackTrace();

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

@@ -4,24 +4,27 @@ import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
-
+import com.volcengine.velive.rn.push.mixer.MixerViewManager;
 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<ViewManager>
+  createViewManagers(ReactApplicationContext reactContext) {
+    List<ViewManager> viewManagers = new ArrayList<>();
+    viewManagers.add(new VeLivePushViewManager());
+    viewManagers.add(new MixerViewManager());
+    return viewManagers;
+  }
 
-    @Override
-    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
-        List<NativeModule> modules = new ArrayList<>();
+  @Override
+  public List<NativeModule>
+  createNativeModules(ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
 
-        modules.add(new VeLivePushModule(reactContext));
+    modules.add(new VeLivePushModule(reactContext));
 
-        return modules;
-    }
+    return modules;
+  }
 }

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

@@ -123,4 +123,20 @@ public class VeLivePushView extends FrameLayout {
     reactContext.getJSModule(RCTEventEmitter.class)
         .receiveEvent(getId(), "load", event);
   }
+
+  @Override
+  protected void onAttachedToWindow() {
+    super.onAttachedToWindow();
+    if (viewId != null && hasRegister) {
+      VolcViewManager.putViewById(viewId, this);
+    }
+  }
+
+  @Override
+  protected void onDetachedFromWindow() {
+    super.onDetachedFromWindow();
+    if (viewId != null) {
+//      VolcViewManager.removeViewById(viewId);
+    }
+  }
 }

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

@@ -3,6 +3,8 @@ package com.volcengine.velive.rn.push;
 import android.os.Looper;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.common.MapBuilder;
 import com.facebook.react.uimanager.SimpleViewManager;
@@ -12,8 +14,10 @@ import java.util.Map;
 
 public class VeLivePushViewManager extends SimpleViewManager<VeLivePushView> {
   public static final String NAME = "VeLivePushView";
-
-  private ThemedReactContext context;
+  
+  public  static ReactApplicationContext ctx;
+  
+  public ThemedReactContext context;
   
   @NonNull
   @Override
@@ -31,6 +35,7 @@ public class VeLivePushViewManager extends SimpleViewManager<VeLivePushView> {
           "View must be created on the main thread");
     }
     context = reactContext;
+    ctx = context.getReactApplicationContext();
     return new VeLivePushView(reactContext);
   }
 

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

@@ -0,0 +1,410 @@
+package com.volcengine.velive.rn.push.mixer;
+
+import android.graphics.Bitmap;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import com.ss.avframework.live.VeLivePusher;
+import com.ss.avframework.live.VeLivePusherDef.VeLiveMixVideoLayout;
+import com.ss.avframework.live.VeLivePusherDef.VeLivePusherRenderMode;
+import com.ss.avframework.live.VeLivePusherDef.VeLiveStreamMixDescription;
+import com.ss.avframework.live.VeLiveVideoFrame;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import javax.annotation.Nullable;
+import org.json.JSONObject;
+
+public class MixerManager {
+  public static Map<String, View> cachedMixedViews = new HashMap<>();
+
+  private static final String TAG = "MixerManager";
+
+  private VeLivePusher pusher;
+  private final Map<String, VeLiveMixVideoLayout> mixedViewLayout =
+      new ConcurrentHashMap<>();
+  private final Map<String, Integer> viewIdToStreamId =
+      new ConcurrentHashMap<>();
+  private final Map<String, Integer> pendingCallbacks =
+      new ConcurrentHashMap<>();
+
+  public void setPusher(VeLivePusher pusher) { this.pusher = pusher; }
+
+  /**
+   * Add a view to the mixer
+   * @param viewId Unique identifier for the view
+   * @param viewInfo Configuration for the view
+   * @return streamId for this view
+   */
+  public int addView(String viewId, JSONObject viewInfo) {
+    try {
+      if (pusher == null || pusher.getMixerManager() == null) {
+        return -1;
+      }
+
+      if (viewIdToStreamId.containsKey(viewId)) {
+        return viewIdToStreamId.get(viewId);
+      }
+
+      int videoStreamId = pusher.getMixerManager().addVideoStream();
+      VeLiveStreamMixDescription description = new VeLiveStreamMixDescription();
+      VeLiveMixVideoLayout layout = new VeLiveMixVideoLayout();
+      layout.x = (float)viewInfo.getDouble("x");
+      layout.y = (float)viewInfo.getDouble("y");
+      layout.width = (float)viewInfo.getDouble("width");
+      layout.height = (float)viewInfo.getDouble("height");
+      layout.alpha = (float)viewInfo.optDouble("alpha", 1.0);
+      layout.zOrder = viewInfo.optInt("zOrder", 0);
+      int renderModeValue = viewInfo.optInt("renderMode", 0);
+      VeLivePusherRenderMode[] renderModes = VeLivePusherRenderMode.values();
+      if (renderModeValue >= 0 && renderModeValue < renderModes.length) {
+        layout.renderMode = renderModes[renderModeValue];
+      } else {
+        layout.renderMode = VeLivePusherRenderMode.values()[0];
+      }
+      layout.streamId = videoStreamId;
+      description.mixVideoStreams.add(layout);
+      mixedViewLayout.put(viewId, layout);
+      viewIdToStreamId.put(viewId, videoStreamId);
+      pusher.getMixerManager().updateStreamMixDescription(description);
+
+      View view = cachedMixedViews.get(viewId);
+      if (view instanceof MixerView) {
+        MixerView mixerView = (MixerView)view;
+        setupCallbackForMixerView(mixerView, videoStreamId);
+
+        android.os.Handler mainHandler =
+            new android.os.Handler(android.os.Looper.getMainLooper());
+        mainHandler.postDelayed(new Runnable() {
+          @Override
+          public void run() {
+            try {
+              mixerView.performManualCapture();
+            } catch (Exception e) {
+              Log.w(TAG, "Failed to perform manual capture after addView", e);
+            }
+          }
+        }, 300);
+      } else {
+        pendingCallbacks.put(viewId, videoStreamId);
+      }
+
+      return videoStreamId;
+    } catch (Exception e) {
+      return -1;
+    }
+  }
+
+  /**
+   * Update view configuration
+   */
+  public boolean updateView(String viewId, JSONObject viewInfo) {
+    try {
+      VeLiveMixVideoLayout layout = mixedViewLayout.get(viewId);
+      if (layout == null) {
+        return false;
+      }
+      VeLiveStreamMixDescription description = new VeLiveStreamMixDescription();
+      layout.x = (float)viewInfo.getDouble("x");
+      layout.y = (float)viewInfo.getDouble("y");
+      layout.width = (float)viewInfo.getDouble("width");
+      layout.height = (float)viewInfo.getDouble("height");
+      layout.alpha = (float)viewInfo.optDouble("alpha", 1.0);
+      Integer streamId = viewIdToStreamId.get(viewId);
+      if (streamId != null) {
+        layout.streamId = streamId;
+      }
+      if (viewInfo.has("zOrder")) {
+        layout.zOrder = viewInfo.getInt("zOrder");
+      }
+      if (viewInfo.has("renderMode")) {
+        int renderModeValue = viewInfo.getInt("renderMode");
+        VeLivePusherRenderMode[] renderModes = VeLivePusherRenderMode.values();
+        if (renderModeValue >= 0 && renderModeValue < renderModes.length) {
+          layout.renderMode = renderModes[renderModeValue];
+        }
+      }
+      mixedViewLayout.put(viewId, layout);
+      description.mixVideoStreams.add(layout);
+      pusher.getMixerManager().updateStreamMixDescription(description);
+
+      View view = cachedMixedViews.get(viewId);
+      if (view instanceof MixerView) {
+        MixerView mixerView = (MixerView)view;
+        android.os.Handler mainHandler =
+            new android.os.Handler(android.os.Looper.getMainLooper());
+        mainHandler.postDelayed(new Runnable() {
+          @Override
+          public void run() {
+            try {
+              mixerView.performManualCapture();
+            } catch (Exception e) {
+              Log.w(TAG, "Failed to perform manual capture after update", e);
+            }
+          }
+        }, 300);
+      }
+      return true;
+    } catch (Exception e) {
+      return false;
+    }
+  }
+
+  /**
+   * Remove view from mixer
+   */
+  public boolean removeView(String viewId) {
+    try {
+      VeLiveMixVideoLayout layout = mixedViewLayout.remove(viewId);
+      if (layout == null) {
+        return false;
+      }
+
+      viewIdToStreamId.remove(viewId);
+
+      View view = cachedMixedViews.get(viewId);
+      if (view instanceof MixerView) {
+        MixerView mixerView = (MixerView)view;
+        mixerView.setBitmapCaptureCallback(null);
+      }
+      cachedMixedViews.remove(viewId);
+
+      pusher.getMixerManager().removeVideoStream(layout.streamId);
+      return true;
+
+    } catch (Exception e) {
+      return false;
+    }
+  }
+
+  /**
+   * Manually trigger bitmap capture for a view
+   */
+  public void captureView(String viewId) {
+    View view = cachedMixedViews.get(viewId);
+    if (view instanceof MixerView) {
+      MixerView mixerView = (MixerView)view;
+      mixerView.performManualCapture();
+    }
+  }
+
+  /**
+   * Called when MixerView is ready - check for pending callbacks
+   */
+  public static void onViewReady(String viewId, MixerView mixerView) {
+    try {
+      MixerManager instance = findActiveMixerManager();
+      if (instance != null) {
+        Integer streamId = instance.pendingCallbacks.remove(viewId);
+        if (streamId != null) {
+          setupCallbackForMixerView(mixerView, streamId);
+
+          android.os.Handler mainHandler =
+              new android.os.Handler(android.os.Looper.getMainLooper());
+          mainHandler.postDelayed(new Runnable() {
+            @Override
+            public void run() {
+              try {
+                VeLiveMixVideoLayout layout =
+                    instance.mixedViewLayout.get(viewId);
+                if (layout != null && instance.pusher != null &&
+                    instance.pusher.getMixerManager() != null) {
+                  VeLiveStreamMixDescription description =
+                      new VeLiveStreamMixDescription();
+                  description.mixVideoStreams.add(layout);
+                  instance.pusher.getMixerManager().updateStreamMixDescription(
+                      description);
+                }
+                mixerView.performManualCapture();
+              } catch (Exception e) {
+                Log.w(TAG, "Failed to perform operations in onViewReady", e);
+              }
+            }
+          }, 300);
+        }
+      }
+    } catch (Exception e) {
+      Log.w(TAG, "Error in onViewReady", e);
+    }
+  }
+
+  /**
+   * Send captured bitmap to mixer as video frame
+   */
+  private void sendBitmapToMixer(int streamId, Bitmap bitmap) {
+    try {
+      if (bitmap == null || bitmap.isRecycled()) {
+        return;
+      }
+
+      if (pusher == null || pusher.getMixerManager() == null) {
+        return;
+      }
+
+      int width = bitmap.getWidth();
+      int height = bitmap.getHeight();
+
+      if (width <= 0 || height <= 0) {
+        return;
+      }
+
+      TextureMgr textureMgr = new TextureMgr(width, height);
+      textureMgr.dealWithTexture(bitmap, new TextureMgr.RenderListener() {
+        @Override
+        public void doBusiness(int texture) {
+          try {
+            if (texture <= 0) {
+              return;
+            }
+
+            long pts = System.currentTimeMillis() * 1000;
+            VeLiveVideoFrame videoFrame =
+                new VeLiveVideoFrame(width, height, pts, texture, false, null);
+
+            if (pusher != null && pusher.getMixerManager() != null) {
+              pusher.getMixerManager().sendCustomVideoFrame(videoFrame,
+                                                            streamId);
+            }
+          } catch (Exception e) {
+            // Ignore
+          } finally {
+            textureMgr.cleanup();
+          }
+        }
+      });
+    } catch (Exception e) {
+      // Ignore
+    }
+  }
+
+  /**
+   * Static method to set up callback for MixerView
+   * Now with intelligent layout waiting logic
+   */
+  private static void setupCallbackForMixerView(MixerView mixerView,
+                                                int streamId) {
+    if (mixerView == null) {
+      return;
+    }
+
+    mixerView.setBitmapCaptureCallback(new BitmapCaptureCallback() {
+      @Override
+      public void onBitmapCaptured(Bitmap bitmap) {
+        try {
+          if (bitmap != null && !bitmap.isRecycled()) {
+            sendBitmapToMixerStatic(streamId, bitmap);
+          }
+        } catch (OutOfMemoryError e) {
+          System.gc();
+        } catch (Exception e) {
+          // Ignore
+        }
+      }
+
+      @Override
+      public void onCaptureError(String error) {
+        // Ignore
+      }
+    });
+
+    if (mixerView.getWidth() > 0 && mixerView.getHeight() > 0) {
+      try {
+        mixerView.performManualCapture();
+      } catch (Exception e) {
+        // Ignore
+      }
+    } else {
+      ViewTreeObserver.OnGlobalLayoutListener layoutListener =
+          new ViewTreeObserver.OnGlobalLayoutListener() {
+            @Override
+            public void onGlobalLayout() {
+              try {
+                if (mixerView.getViewTreeObserver().isAlive()) {
+                  if (mixerView.getWidth() > 0 && mixerView.getHeight() > 0) {
+                    mixerView.getViewTreeObserver()
+                        .removeOnGlobalLayoutListener(this);
+                    mixerView.performManualCapture();
+                  }
+                }
+              } catch (Exception e) {
+                // Ignore
+              }
+            }
+          };
+
+      try {
+        mixerView.getViewTreeObserver().addOnGlobalLayoutListener(
+            layoutListener);
+      } catch (Exception e) {
+        // Ignore
+      }
+    }
+  }
+
+  /**
+   * Static version of sendBitmapToMixer - finds the active MixerManager
+   * instance
+   */
+  private static void sendBitmapToMixerStatic(int streamId, Bitmap bitmap) {
+    try {
+      MixerManager instance = findActiveMixerManager();
+      if (instance != null && instance.pusher != null) {
+        instance.sendBitmapToMixer(streamId, bitmap);
+      }
+    } catch (Exception e) {
+      // Ignore
+    }
+  }
+
+  /**
+   * Find the active MixerManager instance
+   */
+  private static MixerManager findActiveMixerManager() {
+    MixerManager instance = currentInstance;
+    if (instance != null && instance.pusher != null) {
+      return instance;
+    }
+    return null;
+  }
+
+  private static volatile MixerManager currentInstance;
+
+  public MixerManager() {
+    synchronized (MixerManager.class) { currentInstance = this; }
+  }
+
+  /**
+   * cleanup method to release resources
+   */
+  public void cleanup() {
+    try {
+      for (String viewId : cachedMixedViews.keySet()) {
+        View view = cachedMixedViews.get(viewId);
+        if (view instanceof MixerView) {
+          MixerView mixerView = (MixerView)view;
+          mixerView.setBitmapCaptureCallback(null);
+        }
+      }
+
+      mixedViewLayout.clear();
+      viewIdToStreamId.clear();
+      pendingCallbacks.clear();
+
+      synchronized (MixerManager.class) {
+        if (currentInstance == this) {
+          currentInstance = null;
+        }
+      }
+
+      pusher = null;
+    } catch (Exception e) {
+      // Ignore
+    }
+  }
+
+  // Callback interface for bitmap capture
+  public interface BitmapCaptureCallback {
+    void onBitmapCaptured(Bitmap bitmap);
+    void onCaptureError(String error);
+  }
+}