@byteplus/react-native-live-push 1.1.3-rc.1 → 1.1.3-rc.2

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

@@ -0,0 +1,415 @@
+package com.volcengine.velive.rn.push.mixer;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.ViewTreeObserver;
+import android.widget.FrameLayout;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.ThemedReactContext;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Custom MixerView that supports different capture modes
+ */
+public class MixerView extends FrameLayout {
+  private ThemedReactContext context;
+  private String viewId;
+
+  // Mix configuration
+  private float mixX = 0f;
+  private float mixY = 0f;
+  private float mixWidth = 0f;
+  private float mixHeight = 0f;
+  private int mixZOrder = 0;
+  private int mixRenderMode = 0;
+
+  // Capture configuration
+  private String captureMode = "onchange";
+  private float captureFramerate = 30f;
+  private float autoSensitivity = 5f;
+
+  // Capture state
+  private Handler captureHandler;
+  private Runnable captureRunnable;
+  private ViewTreeObserver.OnGlobalLayoutListener layoutListener;
+  private ViewTreeObserver.OnDrawListener drawListener;
+  private AtomicBoolean isCapturing = new AtomicBoolean(false);
+  private AtomicBoolean isDestroyed = new AtomicBoolean(false);
+
+  // Performance optimization
+  private Bitmap lastBitmap;
+  private long lastCaptureTime = 0;
+  private final Object captureLock = new Object();
+
+  // Auto mode state
+  private int changeCount = 0;
+  private long windowStartTime = 0;
+  private boolean isInRealtimeMode = false;
+  private static final long AUTO_WINDOW_MS = 2000; // 2 second window
+  private static final int HIGH_CHANGE_THRESHOLD = 10;
+  private static final int LOW_CHANGE_THRESHOLD = 2;
+
+  // Add callback support for MixerManager integration
+  private MixerManager.BitmapCaptureCallback bitmapCaptureCallback;
+
+  public MixerView(ThemedReactContext context) {
+    super(context);
+    this.context = context;
+    this.captureHandler = new Handler(Looper.getMainLooper());
+    initializeCapture();
+  }
+
+  private void initializeCapture() {
+    // Initialize layout change listener
+    layoutListener = this::onViewChanged;
+
+    // Initialize draw listener for auto mode
+    drawListener = this::onViewDraw;
+  }
+
+  // Setters for mix configuration
+  public void setMixX(float x) { this.mixX = x; }
+  public void setMixY(float y) { this.mixY = y; }
+  public void setMixWidth(float width) { this.mixWidth = width; }
+  public void setMixHeight(float height) { this.mixHeight = height; }
+  public void setMixZOrder(int zOrder) { this.mixZOrder = zOrder; }
+  public void setMixRenderMode(int renderMode) {
+    this.mixRenderMode = renderMode;
+  }
+
+  public void setCaptureMode(String mode) {
+    if (mode.equals(this.captureMode))
+      return;
+
+    stopCapture();
+    this.captureMode = mode;
+    startCapture();
+  }
+
+  public void setCaptureFramerate(float framerate) {
+    this.captureFramerate = Math.max(1f, Math.min(60f, framerate));
+    if ("realtime".equals(captureMode)) {
+      restartRealtimeCapture();
+    }
+  }
+
+  public void setAutoSensitivity(float sensitivity) {
+    this.autoSensitivity = Math.max(1f, Math.min(10f, sensitivity));
+  }
+
+  private void startCapture() {
+    if (isDestroyed.get())
+      return;
+
+    switch (captureMode) {
+    case "onchange":
+      startOnChangeCapture();
+      break;
+    case "realtime":
+      startRealtimeCapture();
+      break;
+    case "auto":
+      startAutoCapture();
+      break;
+    case "manual":
+      // Manual mode doesn't auto-start
+      break;
+    }
+  }
+
+  private void stopCapture() {
+    // Remove listeners
+    if (getViewTreeObserver().isAlive()) {
+      if (layoutListener != null) {
+        getViewTreeObserver().removeOnGlobalLayoutListener(layoutListener);
+      }
+      if (drawListener != null) {
+        getViewTreeObserver().removeOnDrawListener(drawListener);
+      }
+    }
+
+    // Stop realtime capture
+    if (captureRunnable != null) {
+      captureHandler.removeCallbacks(captureRunnable);
+      captureRunnable = null;
+    }
+
+    isCapturing.set(false);
+  }
+
+  private void startOnChangeCapture() {
+    if (getViewTreeObserver().isAlive()) {
+      getViewTreeObserver().addOnGlobalLayoutListener(layoutListener);
+    }
+  }
+
+  private void startRealtimeCapture() {
+    long interval = (long)(1000f / captureFramerate);
+    
+    captureRunnable = new Runnable() {
+      @Override
+      public void run() {
+        if (!isDestroyed.get() && "realtime".equals(captureMode)) {
+          performCapture("realtime");
+          captureHandler.postDelayed(this, interval);
+        }
+      }
+    };
+    captureHandler.postDelayed(captureRunnable, interval);
+  }
+
+  private void restartRealtimeCapture() {
+    if ("realtime".equals(captureMode)) {
+      stopCapture();
+      startRealtimeCapture();
+    }
+  }
+
+  private void startAutoCapture() {
+    // Start with onchange mode
+    isInRealtimeMode = false;
+    windowStartTime = System.currentTimeMillis();
+    changeCount = 0;
+
+    if (getViewTreeObserver().isAlive()) {
+      getViewTreeObserver().addOnGlobalLayoutListener(layoutListener);
+      getViewTreeObserver().addOnDrawListener(drawListener);
+    }
+  }
+
+  private void onViewChanged() {
+    if (isDestroyed.get()) {
+      return;
+    }
+
+    switch (captureMode) {
+    case "onchange":
+      performCapture("onchange");
+      break;
+    case "auto":
+      handleAutoModeChange();
+      break;
+    }
+  }
+
+  private void onViewDraw() {
+    if (isDestroyed.get() || !"auto".equals(captureMode))
+      return;
+
+    // Count draws for auto mode sensitivity
+    changeCount++;
+
+    long currentTime = System.currentTimeMillis();
+    if (currentTime - windowStartTime >= AUTO_WINDOW_MS) {
+      evaluateAutoMode();
+      // Reset window
+      windowStartTime = currentTime;
+      changeCount = 0;
+    }
+  }
+
+  private void handleAutoModeChange() {
+    if (!isInRealtimeMode) {
+      performCapture("auto_onchange");
+    }
+  }
+
+  private void evaluateAutoMode() {
+    float changesPerSecond = changeCount * 1000f / AUTO_WINDOW_MS;
+    float threshold = autoSensitivity;
+
+    boolean shouldBeRealtime =
+        changesPerSecond > (HIGH_CHANGE_THRESHOLD / threshold);
+    boolean shouldBeOnChange =
+        changesPerSecond < (LOW_CHANGE_THRESHOLD / threshold);
+
+    if (shouldBeRealtime && !isInRealtimeMode) {
+      switchToRealtimeMode();
+    } else if (shouldBeOnChange && isInRealtimeMode) {
+      switchToOnChangeMode();
+    }
+  }
+
+  private void switchToRealtimeMode() {
+    isInRealtimeMode = true;
+    startRealtimeCapture();
+  }
+
+  private void switchToOnChangeMode() {
+    isInRealtimeMode = false;
+    // Stop realtime capture but keep layout listener
+    if (captureRunnable != null) {
+      captureHandler.removeCallbacks(captureRunnable);
+      captureRunnable = null;
+    }
+  }
+
+  private void performCapture(String trigger) {
+    if (isCapturing.get() || isDestroyed.get()) {
+      return;
+    }
+
+    long currentTime = System.currentTimeMillis();
+    if (currentTime - lastCaptureTime < 16) {
+      return;
+    }
+    lastCaptureTime = currentTime;
+    
+    synchronized (captureLock) {
+      if (isCapturing.compareAndSet(false, true)) {
+        Bitmap bitmap = null;
+        try {
+          bitmap = createBitmap();
+          if (bitmap != null) {
+            processBitmap(bitmap, trigger);
+          }
+        } catch (OutOfMemoryError e) {
+          System.gc();
+          if (bitmap != null && !bitmap.isRecycled()) {
+            bitmap.recycle();
+            bitmap = null;
+          }
+        } finally {
+          isCapturing.set(false);
+        }
+      }
+    }
+  }
+
+  private Bitmap createBitmap() {
+    if (getWidth() <= 0 || getHeight() <= 0)
+      return null;
+
+    try {
+      Bitmap bitmap =
+          Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888);
+      Canvas canvas = new Canvas(bitmap);
+      draw(canvas);
+      return bitmap;
+    } catch (OutOfMemoryError e) {
+      // Try with lower quality
+      try {
+        Bitmap bitmap =
+            Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.RGB_565);
+        Canvas canvas = new Canvas(bitmap);
+        draw(canvas);
+        return bitmap;
+      } catch (Exception ex) {
+        return null;
+      }
+    }
+  }
+
+  private void processBitmap(Bitmap bitmap, String trigger) {
+    if (bitmap == null || bitmap.isRecycled()) {
+      if (bitmapCaptureCallback != null) {
+        bitmapCaptureCallback.onCaptureError("Bitmap is null or recycled");
+      }
+      return;
+    }
+    
+    // Call callback first if set (for MixerManager)
+    if (bitmapCaptureCallback != null) {
+      try {
+        bitmapCaptureCallback.onBitmapCaptured(bitmap);
+      } catch (Exception e) {
+        if (bitmapCaptureCallback != null) {
+          bitmapCaptureCallback.onCaptureError("Callback error: " + e.getMessage());
+        }
+      }
+    } else {
+      // Send event to JS (existing functionality)
+      try {
+        WritableMap event = Arguments.createMap();
+        event.putString("trigger", trigger);
+        event.putBoolean("success", true);
+        event.putDouble("x", mixX);
+        event.putDouble("y", mixY);
+        event.putDouble("width", mixWidth);
+        event.putDouble("height", mixHeight);
+        event.putInt("zOrder", mixZOrder);
+        event.putInt("renderMode", mixRenderMode);
+        event.putInt("bitmapWidth", bitmap.getWidth());
+        event.putInt("bitmapHeight", bitmap.getHeight());
+      } catch (IllegalStateException e) {
+        // Ignore
+      }
+    }
+
+    // Clean up old bitmap
+    if (lastBitmap != null && !lastBitmap.isRecycled()) {
+      lastBitmap.recycle();
+    }
+    lastBitmap = bitmap;
+  }
+
+  public void handleCommand(String command, @Nullable ReadableArray args) {
+    switch (command) {
+    case "capture":
+      performCapture("manual");
+      break;
+    case "startCapture":
+      startCapture();
+      break;
+    case "stopCapture":
+      stopCapture();
+      break;
+    case "setCaptureMode":
+      if (args != null && args.size() > 0) {
+        setCaptureMode(args.getString(0));
+      }
+      break;
+    }
+  }
+
+  @Override
+  protected void onAttachedToWindow() {
+    super.onAttachedToWindow();
+    if (viewId != null) {
+      MixerManager.cachedMixedViews.put(viewId, this);
+      // 通知MixerManager视图已准备好，检查是否有待处理的回调
+      MixerManager.onViewReady(viewId, this);
+    }
+  }
+  
+  @Override
+  protected void onDetachedFromWindow() {
+    super.onDetachedFromWindow();
+    if (viewId != null) {
+      MixerManager.cachedMixedViews.remove(viewId);
+    }
+    cleanup();
+  }
+  
+  public void setViewId(String viewId) { 
+    this.viewId = viewId; 
+    MixerManager.cachedMixedViews.put(viewId, this);
+    // 通知MixerManager视图已准备好，检查是否有待处理的回调
+    MixerManager.onViewReady(viewId, this);
+  }
+
+  // Add callback support for MixerManager integration
+  public void setBitmapCaptureCallback(MixerManager.BitmapCaptureCallback callback) {
+    this.bitmapCaptureCallback = callback;
+  }
+
+  // Public method for manual capture (called by MixerManager)
+  public void performManualCapture() {
+    performCapture("manual");
+  }
+  
+  private void cleanup() {
+    isDestroyed.set(true);
+    stopCapture();
+
+    if (lastBitmap != null && !lastBitmap.isRecycled()) {
+      lastBitmap.recycle();
+      lastBitmap = null;
+    }
+  }
+} 

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

@@ -0,0 +1,79 @@
+package com.volcengine.velive.rn.push.mixer;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+public class MixerViewManager extends ViewGroupManager<MixerView> {
+  public static final String NAME = "VeLiveMixView";
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @NonNull
+  @Override
+  protected MixerView
+  createViewInstance(@NonNull ThemedReactContext reactContext) {
+    return new MixerView(reactContext);
+  }
+
+  // Props for mixing configuration
+  @ReactProp(name = "x", defaultFloat = 0f)
+  public void setX(MixerView view, float x) {
+    view.setMixX(x);
+  }
+
+  @ReactProp(name = "y", defaultFloat = 0f)
+  public void setY(MixerView view, float y) {
+    view.setMixY(y);
+  }
+
+  @ReactProp(name = "width", defaultFloat = 0f)
+  public void setWidth(MixerView view, float width) {
+    view.setMixWidth(width);
+  }
+
+  @ReactProp(name = "height", defaultFloat = 0f)
+  public void setHeight(MixerView view, float height) {
+    view.setMixHeight(height);
+  }
+
+  @ReactProp(name = "zOrder", defaultInt = 0)
+  public void setZOrder(MixerView view, int zOrder) {
+    view.setMixZOrder(zOrder);
+  }
+
+  @ReactProp(name = "renderMode", defaultInt = 0)
+  public void setRenderMode(MixerView view, int renderMode) {
+    view.setMixRenderMode(renderMode);
+  }
+
+  @ReactProp(name = "captureMode")
+  public void setCaptureMode(MixerView view, @Nullable String captureMode) {
+    view.setCaptureMode(captureMode != null ? captureMode : "onchange");
+  }
+
+  @ReactProp(name = "captureFramerate", defaultFloat = 30f)
+  public void setCaptureFramerate(MixerView view, float framerate) {
+    view.setCaptureFramerate(framerate);
+  }
+
+  @ReactProp(name = "autoSensitivity", defaultFloat = 5f)
+  public void setAutoSensitivity(MixerView view, float sensitivity) {
+    view.setAutoSensitivity(sensitivity);
+  }
+
+  @ReactProp(name = "viewId")
+  public void setViewId(MixerView view, @Nullable String viewId) {
+    if (viewId != null) {
+      view.setViewId(viewId);
+    }
+  }
+}
+
+

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

@@ -0,0 +1,168 @@
+package com.volcengine.velive.rn.push.mixer;
+
+import android.graphics.Bitmap;
+import android.opengl.GLES20;
+import android.opengl.GLUtils;
+
+import com.pandora.common.env.Env;
+import com.ss.avframework.opengl.GLThreadManager;
+import com.ss.avframework.opengl.GlUtil;
+
+import java.nio.ByteBuffer;
+
+public class TextureMgr {
+    private int texture;
+    private int width;
+    private int height;
+    public TextureMgr(int width, int height) {
+        this.width = width;
+        this.height = height;
+        GLThreadManager.getMainGlHandle().post(() -> {
+            if (texture <= 0) {
+                texture = GlUtil.generateTexture(GLES20.GL_TEXTURE_2D);
+                GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+                GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texture);
+                GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, width, height, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
+                GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+                GLES20.glFinish();
+                GlUtil.checkNoGLES2Error("clearBackgroundTex");
+            }
+        });
+    }
+
+    public void cleanup() {
+        GLThreadManager.getMainGlHandle().post(() -> {
+            if (texture > 0) {
+                GLES20.glDeleteTextures(1, new int[]{texture}, 0);
+                texture = 0;
+            }
+        });
+    }
+
+    public interface RenderListener {
+        void doBusiness(int texture);
+    }
+
+    public void dealWithTexture(ByteBuffer byteBuffer, RenderListener listener) {
+        GLThreadManager.getMainGlHandle().post(new Runnable() {
+            @Override
+            public void run() {
+                if (texture > 0) {
+                    YuvHelper.NV21ToBitmap bm = null;
+                    Bitmap bmp = null;
+                    Bitmap rotatedBmp = null;
+                    try {
+                        bm = new YuvHelper.NV21ToBitmap(Env.getApplicationContext());
+                        bmp = bm.nv21ToBitmap(byteBuffer.array(), width, height);
+                        
+                        if (bmp == null || bmp.isRecycled()) {
+                            return;
+                        }
+                        
+                        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texture);
+                        rotatedBmp = YuvHelper.rotateBitmap(bmp, 0, false, true);
+                        
+                        if (rotatedBmp != null && !rotatedBmp.isRecycled()) {
+                            GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, rotatedBmp, 0);
+                            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+                            GLES20.glFlush();
+                            listener.doBusiness(texture);
+                        } else {
+                            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+                        }
+                    } catch (OutOfMemoryError e) {
+                        System.gc();
+                    } catch (Exception e) {
+                        // Ignore
+                    } finally {
+                        if (bmp != null && !bmp.isRecycled()) {
+                            bmp.recycle();
+                        }
+                        if (rotatedBmp != null && rotatedBmp != bmp && !rotatedBmp.isRecycled()) {
+                            rotatedBmp.recycle();
+                        }
+                        if (bm != null) {
+                            bm.cleanup();
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    public void dealI420WithTexture(ByteBuffer byteBuffer, RenderListener listener) {
+        GLThreadManager.getMainGlHandle().post(new Runnable() {
+            @Override
+            public void run() {
+                if (texture > 0) {
+                    Bitmap bm = null;
+                    Bitmap rotatedBm = null;
+                    try {
+                        bm = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+                        bm.copyPixelsFromBuffer(byteBuffer);
+                        
+                        if (bm.isRecycled()) {
+                            return;
+                        }
+                        
+                        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texture);
+                        rotatedBm = YuvHelper.rotateBitmap(bm, 0, false, true);
+                        
+                        if (rotatedBm != null && !rotatedBm.isRecycled()) {
+                            GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, rotatedBm, 0);
+                            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+                            GLES20.glFlush();
+                            listener.doBusiness(texture);
+                        } else {
+                            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+                        }
+                    } catch (OutOfMemoryError e) {
+                        System.gc();
+                    } catch (Exception e) {
+                        // Ignore
+                    } finally {
+                        if (bm != null && !bm.isRecycled()) {
+                            bm.recycle();
+                        }
+                        if (rotatedBm != null && rotatedBm != bm && !rotatedBm.isRecycled()) {
+                            rotatedBm.recycle();
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    public void dealWithTexture(Bitmap bitmap, RenderListener listener) {
+        GLThreadManager.getMainGlHandle().post(() -> {
+            if (texture > 0) {
+                Bitmap processedBitmap = null;
+                try {
+                    if (bitmap == null || bitmap.isRecycled()) {
+                        return;
+                    }
+                    
+                    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texture);
+                    processedBitmap = YuvHelper.rotateBitmap(bitmap, 0, false, true);
+                    
+                    if (processedBitmap != null && !processedBitmap.isRecycled()) {
+                        GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, processedBitmap, 0);
+                        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+                        GLES20.glFlush();
+                        listener.doBusiness(texture);
+                    } else {
+                        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+                    }
+                } catch (OutOfMemoryError e) {
+                    System.gc();
+                } catch (Exception e) {
+                    // Ignore
+                } finally {
+                    if (processedBitmap != null && processedBitmap != bitmap && !processedBitmap.isRecycled()) {
+                        processedBitmap.recycle();
+                    }
+                }
+            }
+        });
+    }
+}