@volcengine/react-native-live-pull 1.0.3-rc.0 → 1.1.1-rc.0

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

@@ -0,0 +1,280 @@
+package com.volcengine.velive.rn.pull.pictureInpicture;
+
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+import android.view.SurfaceView;
+import com.ss.videoarch.liveplayer.VeLivePlayer;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Manager class that provides easy access to Picture-in-Picture functionality
+ * for React Native code.
+ */
+public class PictureInPictureManager {
+  private static final String TAG = "PipManager";
+  private static PictureInPictureManager sInstance;
+  private final FloatingWindowHelper mFloatingWindowHelper;
+
+  private Context mContext;
+  private SurfaceView mSurfaceView;
+  private VeLivePlayer mPlayer;
+  // Flag indicating whether we're in the process of switching to PIP mode
+  // Used to control SurfaceView switching state
+  private boolean mSwitchingToPip = false;
+  private IFloatingWindowHelper.Config mConfig =
+      new IFloatingWindowHelper.Config(16f / 9f, 0, 0);
+  private Listener mListener;
+
+  private PictureInPictureManager() {
+    mFloatingWindowHelper = FloatingWindowHelper.getInstance();
+    setupFloatingWindowListener();
+  }
+
+  public static synchronized PictureInPictureManager getInstance() {
+    if (sInstance == null) {
+      sInstance = new PictureInPictureManager();
+    }
+    return sInstance;
+  }
+
+  /**
+   * Set the player instance to be managed
+   */
+  public void setupPlayer(VeLivePlayer player, Context context,
+                          SurfaceView surfaceView) {
+    mPlayer = player;
+    mContext = context;
+    mSurfaceView = surfaceView;
+
+    // Register player with reference manager
+    if (player instanceof VeLiveRefManager.IObject) {
+      VeLiveRefManager.addRef((VeLiveRefManager.IObject)player);
+    }
+  }
+
+  public void setupConfig(float aspectRatio, int x, int y) {
+    mConfig = new IFloatingWindowHelper.Config(aspectRatio, x, y);
+  }
+
+  /**
+   * Check if the device supports picture-in-picture
+   * @return true if supported and has permission, false otherwise
+   */
+  public boolean isPictureInPictureSupported() {
+    return FloatingWindowHelper.isPictureInPictureSupported();
+  }
+
+  public boolean startPictureInPicture() {
+    return startPictureInPicture(mConfig);
+  }
+
+  public boolean startPictureInPicture(float aspectRatio, int x, int y) {
+    mConfig = new IFloatingWindowHelper.Config(aspectRatio, x, y);
+    return startPictureInPicture(mConfig);
+  }
+
+  /**
+   * Start picture-in-picture mode
+   * @return true if PIP was started, false otherwise
+   */
+  public boolean startPictureInPicture(IFloatingWindowHelper.Config config) {
+    Log.d(TAG, "Starting picture-in-picture mode");
+    if (mPlayer == null) {
+      Log.e(TAG, "Cannot start PIP: player is null");
+      return false;
+    }
+
+    if (mFloatingWindowHelper.isOpen()) {
+      Log.d(TAG, "PIP already active");
+      return true;
+    }
+
+    // Check overlay permissions
+    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M &&
+        !android.provider.Settings.canDrawOverlays(mContext)) {
+      Log.d(TAG, "Requesting overlay permission");
+      mFloatingWindowHelper.requestOverlayPermission(mContext);
+      return false;
+    }
+
+    // Mark that we're switching to PIP mode
+    // This flag will be used in onUpdateSurfaceView callback
+    mSwitchingToPip = true;
+
+    // Default empty data
+    Map<String, Object> extraData = new HashMap<>();
+
+    // Call FloatingWindowHelper to open the floating window
+    mFloatingWindowHelper.openFloatingWindow(mContext, config, extraData);
+    return true;
+  }
+
+  /**
+   * Stop picture-in-picture mode
+   */
+  public void stopPictureInPicture() {
+    Log.d(TAG, "Stopping picture-in-picture mode");
+
+    // Ensure the floating window is closed
+    if (mFloatingWindowHelper.isOpen() && mContext != null) {
+      mFloatingWindowHelper.closeFloatingWindow(mContext);
+    }
+
+    // Reset the state flag regardless of whether the window was closed
+    // successfully
+    mSwitchingToPip = false;
+  }
+
+  /**
+   * Check if picture-in-picture is active
+   *
+   * @return true if PIP is active, false otherwise
+   */
+  public boolean isPictureInPictureActive() {
+    return mFloatingWindowHelper.isOpen();
+  }
+
+  /**
+   * Request overlay permission if needed
+   *
+   * @param context Android context
+   */
+  public void requestOverlayPermission(Context context) {
+    mFloatingWindowHelper.requestOverlayPermission(context);
+  }
+
+  /**
+   * Set up floating window listener
+   */
+  private void setupFloatingWindowListener() {
+    mFloatingWindowHelper.setEventListener(
+        new IFloatingWindowHelper.Listener() {
+          @Override
+          public void onOpenFloatingWindowResult(
+              int errCode, Map<String, Object> extraData) {
+            if (errCode == ERR_RETRY) {
+              // Retry
+              startPictureInPicture(mConfig);
+              return;
+            }
+            if (mListener != null) {
+              if (errCode == ERR_NO) {
+                mListener.onStartPictureInPicture();
+              } else {
+                mListener.onError(errCode, extraData);
+              }
+            }
+            Log.d(TAG, "PIP window opened");
+          }
+
+          @Override
+          public void onUpdateSurfaceView(SurfaceView surfaceView) {
+            Log.d(TAG, "onUpdateSurfaceView called with new SurfaceView");
+            if (mSwitchingToPip && mPlayer != null && surfaceView != null) {
+              Log.d(TAG, "Switching player to PIP surface");
+              // Switch player to the SurfaceView provided by
+              // FloatingWindowService
+              mPlayer.setSurfaceHolder(surfaceView.getHolder());
+              // Reset the flag after switching is complete
+              mSwitchingToPip = false;
+            }
+          }
+
+          @Override
+          public void onClickFloatingWindow(Context context) {
+            if (mListener != null) {
+              mListener.onClickPictureInPicture();
+            }
+            Log.d(TAG, "PIP window clicked");
+
+            try {
+              // Get the package manager and launch the app's main activity
+              String packageName = context.getPackageName();
+              Intent launchIntent =
+                  context.getPackageManager().getLaunchIntentForPackage(
+                      packageName);
+
+              if (launchIntent != null) {
+                Log.d(TAG, "Launching app with intent: " + launchIntent);
+                launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                context.startActivity(launchIntent);
+              } else {
+                Log.e(TAG, "Could not create launch intent for package: " +
+                               packageName);
+              }
+            } catch (Exception e) {
+              Log.e(TAG, "Error launching app: " + e.getMessage(), e);
+            }
+
+            // Close the floating window
+            mFloatingWindowHelper.closeFloatingWindow(context);
+          }
+
+          @Override
+          public void onClickFloatingWindowCloseBtn(Context context) {
+            Log.d(TAG, "PIP close button clicked");
+            mFloatingWindowHelper.closeFloatingWindow(context);
+          }
+
+          @Override
+          public void onCloseFloatingWindow(Map<String, Object> extraData) {
+            if (mListener != null) {
+              mListener.onStopPictureInPicture();
+            }
+            Log.d(TAG, "PIP window closed");
+            // Ensure we're completely out of PIP mode
+            mSwitchingToPip = false;
+            if (mPlayer != null && mSurfaceView != null) {
+              Log.d(TAG, "Switching player back to original surface");
+              mPlayer.setSurfaceHolder(mSurfaceView.getHolder());
+            }
+
+            // Release player reference when closing
+            if (mPlayer instanceof VeLiveRefManager.IObject) {
+              VeLiveRefManager.decRef((VeLiveRefManager.IObject)mPlayer);
+            }
+          }
+        });
+  }
+
+  public void setListener(Listener listener) { mListener = listener; }
+
+  public interface Listener {
+    /**
+     * Callback when picture-in-picture mode starts
+     * Default empty implementation, subclasses can override as needed
+     */
+    public default void onStartPictureInPicture() {
+      // Empty implementation, subclasses can override as needed
+    }
+
+    /**
+     * Callback when picture-in-picture mode stops
+     * Default empty implementation, subclasses can override as needed
+     */
+    public default void onStopPictureInPicture() {
+      // Empty implementation, subclasses can override as needed
+    }
+
+    /**
+     * Callback when the picture-in-picture window is clicked
+     * Default empty implementation, subclasses can override as needed
+     */
+    public default void onClickPictureInPicture() {
+      // Empty implementation, subclasses can override as needed
+    }
+
+    /**
+     * Error callback
+     * @param errCode Error code, 0 means success, other values indicate errors
+     * @param extraData Additional data, can be used to pass error information
+     * Default empty implementation, subclasses can override as needed
+     */
+    public default void onError(int errCode, Map<String, Object> extraData) {
+      // Empty implementation, subclasses can override as needed
+    }
+  }
+  ;
+}

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

@@ -0,0 +1,119 @@
+package com.volcengine.velive.rn.pull.pictureInpicture;
+
+import android.util.Log;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Player reference count manager
+ * Used to share player instances between Activity and floating window
+ */
+public class VeLiveRefManager {
+  private static final String TAG = "VeLiveRefManager";
+  private static final VeLiveRefManager INSTANCE = new VeLiveRefManager();
+
+  /**
+   * Interface for objects that can be reference-counted
+   */
+  public interface IObject {
+    /**
+     * Get the unique identifier for the object, defaults to the object itself
+     */
+    default Object getId() { return this; }
+
+    /**
+     * Callback triggered when reference count drops to zero
+     */
+    void onDecRef();
+  }
+
+  private static final Map<Object, Integer> mRefMap = new HashMap<>();
+
+  private VeLiveRefManager() {
+    // Private constructor to ensure singleton pattern
+  }
+
+  public static VeLiveRefManager getInstance() { return INSTANCE; }
+
+  /**
+   * Increase the reference count for an object
+   * @param object The object to increase reference count for
+   */
+  public synchronized static void addRef(IObject object) {
+    if (object == null) {
+      Log.d(TAG, "addRef: object is null");
+      return;
+    }
+
+    Object id = object.getId();
+    int refCnt = 1;
+    if (mRefMap.containsKey(id)) {
+      refCnt += mRefMap.get(id);
+    }
+    mRefMap.put(id, refCnt);
+    Log.d(TAG, "addRef: object=" + id + ", new refCnt=" + refCnt);
+  }
+
+  /**
+   * Decrease the reference count for an object
+   * When the count reaches zero, the object's onDecRef method will be called
+   * @param object The object to decrease reference count for
+   */
+  public synchronized static void decRef(IObject object) {
+    if (object == null) {
+      Log.d(TAG, "decRef: object is null");
+      return;
+    }
+
+    Object id = object.getId();
+    if (!mRefMap.containsKey(id)) {
+      Log.d(TAG, "decRef: object=" + id + " not found in refMap");
+      return;
+    }
+
+    int refCnt = mRefMap.get(id) - 1;
+    Log.d(TAG, "decRef: object=" + id + ", new refCnt=" + refCnt);
+
+    if (refCnt <= 0) {
+      mRefMap.remove(id);
+      Log.d(TAG,
+            "decRef: object=" + id + " removed from refMap, calling onDecRef");
+      object.onDecRef();
+    } else {
+      mRefMap.put(id, refCnt);
+    }
+  }
+
+  /**
+   * Get the current reference count for an object
+   * @param object The object to query
+   * @return The reference count, or 0 if the object doesn't exist
+   */
+  public synchronized int getRefCount(IObject object) {
+    if (object == null) {
+      return 0;
+    }
+
+    Object id = object.getId();
+    if (!mRefMap.containsKey(id)) {
+      return 0;
+    }
+
+    return mRefMap.get(id);
+  }
+
+  /**
+   * Clear all reference count records
+   * Note: This will call onDecRef for all objects
+   */
+  public synchronized void clearAll() {
+    Log.d(TAG, "clearAll: clearing all references");
+    for (Map.Entry<Object, Integer> entry : mRefMap.entrySet()) {
+      if (entry.getKey() instanceof IObject) {
+        Log.d(TAG, "clearAll: calling onDecRef for object=" + entry.getKey());
+        ((IObject)entry.getKey()).onDecRef();
+      }
+    }
+    mRefMap.clear();
+  }
+}

package/android/src/main/res/drawable/button_close.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+  android:width="24dp"
+  android:height="24dp"
+  android:autoMirrored="true"
+  android:viewportWidth="612"
+  android:viewportHeight="612">
+  <path
+    android:fillColor="#FF000000"
+    android:pathData="M612,306C612,137.004 474.995,0 306,0C137.004,0 0,137.004 0,
+                        306c0,168.995 137.004,306 306,306C474.995,612 612,474.995 612,
+                        306zM168.3,424.032L286.333,306L168.3,187.967l19.667,-19.667L306,
+                        286.333L424.032,168.3l19.668,19.667L325.667,306L443.7,424.032L424.032,
+                        443.7L306,325.667L187.967,443.7L168.3,424.032z" />
+</vector>

package/android/src/main/res/layout/floating_window_layout.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent">
+
+  <SurfaceView
+    android:id="@+id/surface_view"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+  </SurfaceView>
+  <Button
+    android:id="@+id/surface_close_btn"
+    android:background="@drawable/button_close"
+    android:layout_width="20dp"
+    android:layout_height="20dp"
+    android:layout_marginTop="4dp"
+    android:layout_marginStart="4dp" />
+</RelativeLayout>

package/ios/VeLivePlayerMultiObserver.h

@@ -0,0 +1,54 @@
+#import <Foundation/Foundation.h>
+#import "TTSDKFramework/TVLManager.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * 多观察者管理器 - 用于同时支持多个 VeLivePlayerObserver
+ * 解决不同组件同时需要接收回调的问题
+ */
+@interface VeLivePlayerMultiObserver : NSObject <VeLivePlayerObserver>
+
+/**
+ * 获取单例实例
+ */
++ (instancetype)sharedInstance;
+
+/**
+ * 获取单例实例，等同于 sharedInstance
+ */
++ (instancetype)getInstance;
+
+/**
+ * 设置播放器的观察者为此 MultiObserver
+ * @param player 播放器实例
+ */
+- (void)setupPlayer:(TVLManager *)player;
+
+/**
+ * 添加一个观察者到代理列表
+ * @param observerId 观察者ID，相同ID会覆盖之前的观察者
+ * @param observer 观察者对象
+ */
+- (void)addObserver:(NSString *)observerId observer:(id<VeLivePlayerObserver>)observer;
+
+/**
+ * 从代理列表中移除观察者
+ * @param observerId 观察者ID
+ */
+- (void)removeObserver:(NSString *)observerId;
+
+/**
+ * 获取当前所有注册的观察者
+ * @return 观察者数组
+ */
+- (NSArray *)getObservers;
+
+/**
+ * 清除所有观察者
+ */
+- (void)clearObservers;
+
+@end
+
+NS_ASSUME_NONNULL_END