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

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

@@ -82,8 +82,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,397 @@
+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.VeLiveStreamMixDescription;
+import com.ss.avframework.live.VeLivePusherDef.VeLivePusherRenderMode;
+import com.ss.avframework.live.VeLiveVideoFrame;
+
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import javax.annotation.Nullable;
+
+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.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 {
+             VeLiveMixVideoLayout layout = mixedViewLayout.get(viewId);
+             if (layout != null && pusher != null && pusher.getMixerManager() != null) {
+               VeLiveStreamMixDescription description = new VeLiveStreamMixDescription();
+               description.mixVideoStreams.add(layout);
+               pusher.getMixerManager().updateStreamMixDescription(description);
+             }
+             mixerView.performManualCapture();
+           } catch (Exception e) {
+             // Ignore
+           }
+         }
+       }, 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");
+      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;
+        mixerView.performManualCapture();
+      }
+      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);
+      }
+      
+      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) {
+                // Ignore
+              }
+            }
+          }, 1000);
+        }
+      }
+    } catch (Exception e) {
+      // Ignore
+    }
+  }
+
+  /**
+   * 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 {
+            if (bitmap != null && !bitmap.isRecycled()) {
+              bitmap.recycle();
+            }
+            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;
+    }
+  }
+  
+  /**
+   * 清理资源，防止内存泄漏
+   */
+  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);
+  }
+}