@byteplus/react-native-live-pull 1.1.2-rc.2 → 1.1.3-rc.0

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

@@ -1,5 +1,6 @@
 package com.volcengine.velive.rn.pull.pictureInpicture;
 
+import android.animation.ValueAnimator;
 import android.app.Service;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -24,14 +25,19 @@ import androidx.annotation.Nullable;
 import com.volcengine.velive.rn.pull.R;
 
 public class FloatingWindowService extends Service {
+  private static final int MARGIN_TOP = 40;
+  private static final int MARGIN_BOTTOM = 40;
+  private static final int MARGIN_LEFT = 20;
+  private static final int MARGIN_RIGHT = 20;
   private static final String TAG = FloatingWindowService.class.getSimpleName();
-  private static final int LONGER_SIDE_MAX_LEN = 1000;
 
   private WindowManager mWindowManager;
   private WindowManager.LayoutParams mLayoutParams;
   private SurfaceView mSurfaceView;
   private View mSmallWindowView;
   private ActivityLaunchReceiver mActivityLaunchReceiver;
+  private FloatingOnTouchListener
+      mFloatingOnTouchListener; // Store the listener instance
 
   public static final String ACTION_STOP_PIP_SERVICE =
       "com.volcengine.velive.rn.pull.STOP_PIP_SERVICE";
@@ -97,37 +103,68 @@ public class FloatingWindowService extends Service {
     int screenWidth = displayMetrics.widthPixels;
     int screenHeight = displayMetrics.heightPixels;
 
-    // Calculate the minimum screen dimension
-    int minScreenDim = Math.min(screenWidth, screenHeight);
+    int drawableWidth = screenWidth - MARGIN_LEFT - MARGIN_RIGHT;
+    int drawableHeight = screenHeight - MARGIN_TOP - MARGIN_BOTTOM;
 
-    // Determine the maximum length based on the smaller of 1000 and
-    // minScreenDim
-    int maxLen = Math.min(LONGER_SIDE_MAX_LEN, minScreenDim);
+    boolean isPortrait = screenHeight > screenWidth;
+
+    int maxLen;
+    if (isPortrait) {
+      // 竖屏时，宽度不能超过 drawableWidth
+      maxLen = drawableWidth;
+    } else {
+      // 横屏时，高度不能超过 drawableHeight
+      maxLen = drawableHeight;
+    }
 
-    // Limit the floating window size to prevent it from being too large or too
-    // small, control the longer side to maxLen, scale the shorter
-    // side proportionally
     int width, height;
-    if (aspectRatio >= 1) {
-      height = (int)(maxLen / aspectRatio);
+    if (aspectRatio >= 1) { // 宽大于等于高 (横向视频或方形)
       width = maxLen;
-    } else {
-      width = (int)(maxLen * aspectRatio);
+      height = (int)(width / aspectRatio);
+      if (isPortrait && width > drawableWidth) {
+        width = drawableWidth;
+        height = (int)(width / aspectRatio);
+      }
+      if (!isPortrait &&
+          height > drawableHeight) { // 横屏下，若计算出的高度超出drawableHeight
+        height = drawableHeight;
+        width = (int)(height * aspectRatio);
+      }
+    } else { // 高大于宽 (竖向视频)
       height = maxLen;
+      width = (int)(height * aspectRatio);
+      if (!isPortrait && height > drawableHeight) {
+        height = drawableHeight;
+        width = (int)(height * aspectRatio);
+      }
+      if (isPortrait &&
+          width > drawableWidth) { // 竖屏下，若计算出的宽度超出drawableWidth
+        width = drawableWidth;
+        height = (int)(width / aspectRatio);
+      }
     }
-    mLayoutParams.width = width;
-    mLayoutParams.height = height;
 
-    // Initial position of the floating window
-    mLayoutParams.x = x;
-    mLayoutParams.y = y;
+    // Ensure dimensions are positive
+    mLayoutParams.width = Math.max(1, width);
+    mLayoutParams.height = Math.max(1, height);
+
+    // Initial position of the floating window, respecting margins
+    mLayoutParams.x =
+        Math.max(MARGIN_LEFT,
+                 Math.min(x, screenWidth - mLayoutParams.width - MARGIN_RIGHT));
+    mLayoutParams.y =
+        Math.max(MARGIN_TOP, Math.min(y, screenHeight - mLayoutParams.height -
+                                             MARGIN_BOTTOM));
 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
       if (Settings.canDrawOverlays(this)) {
         LayoutInflater layoutInflater = LayoutInflater.from(this);
         mSmallWindowView =
             layoutInflater.inflate(R.layout.floating_window_layout, null);
-        mSmallWindowView.setOnTouchListener(new FloatingOnTouchListener());
+        this.mFloatingOnTouchListener =
+            new FloatingOnTouchListener(); // Create and store the instance
+        mSmallWindowView.setOnTouchListener(
+            this.mFloatingOnTouchListener); // Set the stored instance
         mWindowManager.addView(mSmallWindowView, mLayoutParams);
         mSurfaceView = mSmallWindowView.findViewById(R.id.surface_view);
         mSmallWindowView.findViewById(R.id.surface_close_btn)
@@ -204,6 +241,8 @@ public class FloatingWindowService extends Service {
   }
 
   private class FloatingOnTouchListener implements View.OnTouchListener {
+    private boolean isDoubleClickAnimating =
+        false; // Flag to indicate if double-click animation is running
     private final int touchSlop =
         ViewConfiguration
             .get(FloatingWindowService.this.getApplicationContext())
@@ -212,36 +251,289 @@ public class FloatingWindowService extends Service {
     private int x, y;
     private boolean isDragging;
 
+    private static final int MODE_NONE = 0;
+    private static final int MODE_DRAG = 1;
+    private static final int MODE_ZOOM = 2;
+    private int mode = MODE_NONE;
+
+    private float oldDist = 1f;
+    private float initialAspectRatio;
+    private int initialWidth;
+    private int initialHeight;
+
+    // Screen metrics
+    private DisplayMetrics displayMetrics = new DisplayMetrics();
+    private int screenWidth;
+    private int screenHeight;
+    private int drawableWidth;
+    private int drawableHeight;
+    private boolean isPortraitScreen;
+
+    private long lastClickTime = 0;
+    private static final long DOUBLE_CLICK_TIME_DELTA = 200; // milliseconds
+
+    private final float ZOOM_SCALE_FACTOR =
+        1.5f; // Factor to zoom in/out on double tap
+
+    private void updateScreenMetrics() {
+      mWindowManager.getDefaultDisplay().getMetrics(displayMetrics);
+      screenWidth = displayMetrics.widthPixels;
+      screenHeight = displayMetrics.heightPixels;
+      drawableWidth = screenWidth - MARGIN_LEFT - MARGIN_RIGHT;
+      drawableHeight = screenHeight - MARGIN_TOP - MARGIN_BOTTOM;
+      isPortraitScreen = screenHeight > screenWidth;
+    }
+
     @Override
     public boolean onTouch(View view, MotionEvent event) {
-      switch (event.getAction()) {
+      // Update screen metrics at the beginning of a touch gesture,
+      // as orientation or screen size might have changed since last touch.
+      if (event.getAction() == MotionEvent.ACTION_DOWN) {
+        updateScreenMetrics();
+      }
+      // If currently animating from double click, consume touch events to
+      // prevent interference
+      if (isDoubleClickAnimating) {
+        // Allow ACTION_UP to potentially clear the flag if animation ends early
+        // or is cancelled but primarily, prevent new gestures from starting.
+        if (event.getAction() == MotionEvent.ACTION_DOWN) {
+          mode = MODE_NONE; // Prevent drag/zoom from starting
+        }
+        return true; // Consume the event
+      }
+      switch (event.getAction() & MotionEvent.ACTION_MASK) {
+      case MotionEvent.ACTION_DOWN:
+        downX = x = (int)event.getRawX();
+        downY = y = (int)event.getRawY();
+        mode = MODE_DRAG;
+        initialAspectRatio = (float)mLayoutParams.width / mLayoutParams.height;
+        initialWidth = mLayoutParams.width;
+        initialHeight = mLayoutParams.height;
+
+        // Double tap detection
+        long clickTime = System.currentTimeMillis();
+        if (clickTime - lastClickTime < DOUBLE_CLICK_TIME_DELTA) {
+          handleDoubleClick(view);
+        }
+        lastClickTime = clickTime;
+        break;
+      case MotionEvent.ACTION_POINTER_DOWN:
+        oldDist = spacing(event);
+        if (oldDist > 10f) {
+          mode = MODE_ZOOM;
+        }
+        break;
       case MotionEvent.ACTION_UP:
+      case MotionEvent.ACTION_POINTER_UP:
+        boolean wasZooming = (mode == MODE_ZOOM);
+        // Capture params before mode is reset
+        int xBeforeSnap = mLayoutParams.x;
+        int widthBeforeSnap = mLayoutParams.width;
+
+        mode = MODE_NONE; // Reset mode
+
         if (isDragging) {
           isDragging = false;
+          // Perform snap animation if it was a drag or end of zoom
+          if (event.getPointerCount() == 1 || wasZooming) {
+            Log.i(TAG, "ACTION_UP/POINTER_UP: Triggering snap. xBeforeSnap=" +
+                           xBeforeSnap + ", widthBeforeSnap=" +
+                           widthBeforeSnap + ", wasZooming=" + wasZooming +
+                           ", pointerCount=" + event.getPointerCount());
+            animateSnapToEdge(view);
+          }
         } else {
-          FloatingWindowHelper.getInstance().onClickFloatingWindow(
-              FloatingWindowService.this);
+          // Only trigger click if not zooming and it's a single pointer up
+          if (event.getPointerCount() == 1 &&
+              (event.getAction() & MotionEvent.ACTION_MASK) ==
+                  MotionEvent.ACTION_UP) {
+            // Check if it was a drag or a tap
+            if (Math.abs(event.getRawX() - downX) < touchSlop &&
+                Math.abs(event.getRawY() - downY) < touchSlop) {
+              // This is a tap, not a double tap, so handle as single click if
+              // needed For now, double tap handles zoom, single tap is handled
+              // by new_window_btn
+            }
+          }
         }
-        downX = downY = 0;
-        break;
-      case MotionEvent.ACTION_DOWN:
-        downX = x = (int)event.getRawX();
-        downY = y = (int)event.getRawY();
+        // downX and downY are reset at ACTION_DOWN for the primary pointer
         break;
+
       case MotionEvent.ACTION_MOVE:
-        int nowX = (int)event.getRawX();
-        int nowY = (int)event.getRawY();
-        if (Math.abs(nowX - downX) > touchSlop ||
-            Math.abs(nowY - downY) > touchSlop) {
-          isDragging = true;
-        }
-        int movedX = nowX - x;
-        int movedY = nowY - y;
-        x = nowX;
-        y = nowY;
-        mLayoutParams.x = mLayoutParams.x + movedX;
-        mLayoutParams.y = mLayoutParams.y + movedY;
-        mWindowManager.updateViewLayout(view, mLayoutParams);
+        if (mode == MODE_DRAG && event.getPointerCount() == 1) {
+          int nowX = (int)event.getRawX();
+          int nowY = (int)event.getRawY();
+          if (!isDragging && (Math.abs(nowX - downX) > touchSlop ||
+                              Math.abs(nowY - downY) > touchSlop)) {
+            isDragging = true;
+          }
+          if (isDragging) {
+            int movedX = nowX - x;
+            int movedY = nowY - y;
+            mLayoutParams.x = mLayoutParams.x + movedX;
+            mLayoutParams.y = mLayoutParams.y + movedY;
+
+            // 使用预先获取的屏幕高度 screenHeight
+            // 限制y坐标在安全区域内
+            mLayoutParams.y = Math.max(
+                MARGIN_TOP, Math.min(mLayoutParams.y, this.screenHeight -
+                                                          mLayoutParams.height -
+                                                          MARGIN_BOTTOM));
+
+            mWindowManager.updateViewLayout(view, mLayoutParams);
+          }
+          x = nowX;
+          y = nowY;
+        } else if (mode == MODE_ZOOM && event.getPointerCount() >= 2) {
+          float newDist = spacing(event);
+          if (newDist > 10f) {
+            // Calculate midpoint of the two fingers
+            float midX = (event.getX(0) + event.getX(1)) / 2;
+            float midY = (event.getY(0) + event.getY(1)) / 2;
+
+            // Convert midpoint from view coordinates to screen coordinates
+            float screenMidX = mLayoutParams.x + midX;
+            float screenMidY = mLayoutParams.y + midY;
+
+            float scale = newDist / oldDist;
+            int oldWidth = mLayoutParams.width;
+            int oldHeight = mLayoutParams.height;
+            int newWidth = (int)(oldWidth * scale);
+            int newHeight = (int)(oldHeight * scale);
+
+            // Use pre-calculated screen metrics
+            // Screen metrics are now updated in onTouch ACTION_DOWN, so they
+            // should be current here.
+
+            // Min size constraints: 1/2 of initial size, but not smaller than a
+            // fraction of screen respecting margins
+            int minAllowedWidth;
+            int minAllowedHeight;
+            if (isPortraitScreen) {
+              minAllowedWidth = Math.max(initialWidth / 2, drawableWidth / 2);
+              minAllowedHeight = (int)(minAllowedWidth / initialAspectRatio);
+            } else {
+              minAllowedHeight =
+                  Math.max(initialHeight / 2, drawableHeight / 2);
+              minAllowedWidth = (int)(minAllowedHeight * initialAspectRatio);
+            }
+            // Ensure min dimensions are at least 1
+            minAllowedWidth = Math.max(1, minAllowedWidth);
+            minAllowedHeight = Math.max(1, minAllowedHeight);
+
+            // Max size constraints based on orientation and margins
+            int maxAllowedWidth, maxAllowedHeight;
+            if (isPortraitScreen) {
+              maxAllowedWidth = drawableWidth;
+              maxAllowedHeight =
+                  (int)(maxAllowedWidth /
+                        initialAspectRatio); // Maintain aspect ratio
+              if (maxAllowedHeight >
+                  drawableHeight) { // If calculated height is too much for
+                                    // portrait
+                maxAllowedHeight = drawableHeight;
+                maxAllowedWidth = (int)(maxAllowedHeight * initialAspectRatio);
+              }
+            } else { // Landscape screen
+              maxAllowedHeight = drawableHeight;
+              maxAllowedWidth =
+                  (int)(maxAllowedHeight *
+                        initialAspectRatio);         // Maintain aspect ratio
+              if (maxAllowedWidth > drawableWidth) { // If calculated width is
+                                                     // too much for landscape
+                maxAllowedWidth = drawableWidth;
+                maxAllowedHeight = (int)(maxAllowedWidth / initialAspectRatio);
+              }
+            }
+            // maxAllowedWidth = Math.min(maxAllowedWidth, LONGER_SIDE_MAX_LEN);
+            // // Global max len - Removed maxAllowedHeight =
+            // Math.min(maxAllowedHeight, LONGER_SIDE_MAX_LEN); // Global max
+            // len - Removed
+            if (initialAspectRatio >= 1)
+              maxAllowedHeight = (int)(maxAllowedWidth / initialAspectRatio);
+            else
+              maxAllowedWidth = (int)(maxAllowedHeight * initialAspectRatio);
+
+            // Apply scaling
+            newWidth = (int)(oldWidth * scale);
+            newHeight = (int)(oldHeight * scale);
+
+            // Clamp to min/max size while maintaining aspect ratio
+            if (scale < 1) { // Shrinking
+              newWidth = Math.max(minAllowedWidth, newWidth);
+              newHeight = (int)(newWidth / initialAspectRatio);
+              if (newHeight < minAllowedHeight) {
+                newHeight = minAllowedHeight;
+                newWidth = (int)(newHeight * initialAspectRatio);
+              }
+            } else { // Expanding
+              newWidth = Math.min(maxAllowedWidth, newWidth);
+              newHeight = (int)(newWidth / initialAspectRatio);
+              if (newHeight > maxAllowedHeight) {
+                newHeight = maxAllowedHeight;
+                newWidth = (int)(newHeight * initialAspectRatio);
+              }
+            }
+
+            // Final check to ensure dimensions are within absolute min/max
+            // bounds
+            newWidth =
+                Math.max(minAllowedWidth, Math.min(newWidth, maxAllowedWidth));
+            newHeight =
+                (int)(newWidth / initialAspectRatio); // Maintain aspect ratio
+            // Ensure height is also clamped correctly after width adjustment
+            if (newHeight < minAllowedHeight) {
+              newHeight = minAllowedHeight;
+              newWidth = (int)(newHeight * initialAspectRatio);
+            }
+            if (newHeight > maxAllowedHeight) {
+              newHeight = maxAllowedHeight;
+              newWidth = (int)(newHeight * initialAspectRatio);
+            }
+            // Re-clamp width just in case height clamping affected it and
+            // pushed it out of width bounds
+            newWidth =
+                Math.max(minAllowedWidth, Math.min(newWidth, maxAllowedWidth));
+
+            // Adjust position to keep the zoom centered on the midpoint
+            mLayoutParams.x = (int)(screenMidX - (midX * newWidth / oldWidth));
+            mLayoutParams.y =
+                (int)(screenMidY - (midY * newHeight / oldHeight));
+
+            mLayoutParams.width = newWidth;
+            mLayoutParams.height = newHeight;
+
+            // Prevent window from going off-screen after repositioning
+            // For Y, keep margin constraints
+            mLayoutParams.y = Math.max(
+                MARGIN_TOP,
+                Math.min(mLayoutParams.y,
+                         screenHeight - mLayoutParams.height - MARGIN_BOTTOM));
+            // For X, constrain to screen physical edges only during zoom,
+            // let animateSnapToEdge handle final margin snapping.
+            mLayoutParams.x = Math.max(
+                0, // Screen physical left edge
+                Math.min(
+                    mLayoutParams.x,
+                    screenWidth -
+                        mLayoutParams.width)); // Screen physical right edge
+
+            // 更新SurfaceView的布局参数
+            if (mSurfaceView != null) {
+              android.view.ViewGroup.LayoutParams surfaceParams =
+                  mSurfaceView.getLayoutParams();
+              if (surfaceParams != null) {
+                surfaceParams.width = mLayoutParams.width;
+                surfaceParams.height = mLayoutParams.height;
+                mSurfaceView.setLayoutParams(surfaceParams);
+              }
+            }
+            mWindowManager.updateViewLayout(view, mLayoutParams);
+            oldDist = newDist;
+          }
+          isDragging =
+              true; // Zooming implies dragging state for click handling
+        }
         break;
 
       default:
@@ -249,5 +541,392 @@ public class FloatingWindowService extends Service {
       }
       return true;
     }
+
+    private float spacing(MotionEvent event) {
+      if (event.getPointerCount() < 2)
+        return 0f;
+      float x = event.getX(0) - event.getX(1);
+      float y = event.getY(0) - event.getY(1);
+      return (float)Math.sqrt(x * x + y * y);
+    }
+
+    private void handleDoubleClick(View view) {
+      Log.d(TAG, "Double tap detected");
+      int targetWidth, targetHeight;
+
+      // Use pre-calculated screen metrics
+      // updateScreenMetrics(); // Ensure metrics are fresh if not updated in
+      // onTouch ACTION_DOWN Screen metrics are now updated in onTouch
+      // ACTION_DOWN, so they should be current here.
+
+      // Minimum size: 1/2 of initial size, but not smaller than a fraction of
+      // screen respecting margins
+      int minAllowedWidth = initialWidth / 2;
+      int minAllowedHeight = initialHeight / 2;
+      if (isPortraitScreen) {
+        minAllowedWidth = Math.max(minAllowedWidth, drawableWidth / 2);
+        minAllowedHeight = (int)(minAllowedWidth / initialAspectRatio);
+      } else {
+        minAllowedHeight = Math.max(minAllowedHeight, drawableHeight / 2);
+        minAllowedWidth = (int)(minAllowedHeight * initialAspectRatio);
+      }
+
+      // Maximum size based on orientation and margins
+      int maxAllowedTargetWidth, maxAllowedTargetHeight;
+      if (isPortraitScreen) {
+        maxAllowedTargetWidth = drawableWidth;
+        maxAllowedTargetHeight =
+            (int)(maxAllowedTargetWidth / initialAspectRatio);
+        if (maxAllowedTargetHeight > drawableHeight) {
+          maxAllowedTargetHeight = drawableHeight;
+          maxAllowedTargetWidth =
+              (int)(maxAllowedTargetHeight * initialAspectRatio);
+        }
+      } else { // Landscape screen
+        maxAllowedTargetHeight = drawableHeight;
+        maxAllowedTargetWidth =
+            (int)(maxAllowedTargetHeight * initialAspectRatio);
+        if (maxAllowedTargetWidth > drawableWidth) {
+          maxAllowedTargetWidth = drawableWidth;
+          maxAllowedTargetHeight =
+              (int)(maxAllowedTargetWidth / initialAspectRatio);
+        }
+      }
+      // Apply global LONGER_SIDE_MAX_LEN constraint - Removed
+      // if (initialAspectRatio >= 1) { // Landscape or square video
+      //   maxAllowedTargetWidth =
+      //       Math.min(maxAllowedTargetWidth, LONGER_SIDE_MAX_LEN);
+      //   maxAllowedTargetHeight =
+      //       (int)(maxAllowedTargetWidth / initialAspectRatio);
+      // } else { // Portrait video
+      //   maxAllowedTargetHeight =
+      //       Math.min(maxAllowedTargetHeight, LONGER_SIDE_MAX_LEN);
+      //   maxAllowedTargetWidth =
+      //       (int)(maxAllowedTargetHeight * initialAspectRatio);
+      // }
+
+      int currentX = mLayoutParams.x;
+      int currentY = mLayoutParams.y;
+      int currentWidth = mLayoutParams.width;
+      int currentHeight = mLayoutParams.height;
+
+      int finalTargetX = currentX;
+      int finalTargetY = currentY;
+
+      // 计算当前宽度与中间值的比较，决定缩放方向
+      int midWidth = (minAllowedWidth + maxAllowedTargetWidth) / 2;
+      if (currentWidth < midWidth) {
+        // 当前更接近最小值，放大到最大尺寸
+        targetWidth = maxAllowedTargetWidth;
+        targetHeight = maxAllowedTargetHeight;
+        Log.d(TAG, "Zooming in to max: " + targetWidth + "x" + targetHeight);
+      } else {
+        // 当前更接近最大值，缩小到最小尺寸
+        targetWidth = minAllowedWidth;
+        targetHeight = minAllowedHeight;
+        Log.d(TAG, "Zooming out to min: " + targetWidth + "x" + targetHeight);
+      }
+
+      // Ensure target dimensions respect calculated min/max and screen
+      // boundaries with margins
+      targetWidth = Math.max(minAllowedWidth,
+                             Math.min(targetWidth, maxAllowedTargetWidth));
+      targetHeight = (int)(targetWidth / initialAspectRatio);
+      if (targetHeight < minAllowedHeight) {
+        targetHeight = minAllowedHeight;
+        targetWidth = (int)(targetHeight * initialAspectRatio);
+      }
+      if (targetHeight > maxAllowedTargetHeight) {
+        targetHeight = maxAllowedTargetHeight;
+        targetWidth = (int)(targetHeight * initialAspectRatio);
+      }
+      // Final check for width after height adjustment
+      targetWidth = Math.max(minAllowedWidth,
+                             Math.min(targetWidth, maxAllowedTargetWidth));
+
+      // Instantly apply new size and update layout BEFORE starting
+      // position/size animations This helps in reducing black bars by setting
+      // the target container size first.
+      mLayoutParams.width = targetWidth;
+      mLayoutParams.height = targetHeight;
+      if (mSmallWindowView != null &&
+          mSmallWindowView.getWindowToken() != null) {
+        mWindowManager.updateViewLayout(mSmallWindowView, mLayoutParams);
+        // Also update SurfaceView's layout params to match the new window size
+        // immediately
+        if (mSurfaceView != null) {
+          android.view.ViewGroup.LayoutParams surfaceParams =
+              mSurfaceView.getLayoutParams();
+          if (surfaceParams != null) {
+            surfaceParams.width = targetWidth;
+            surfaceParams.height = targetHeight;
+            mSurfaceView.setLayoutParams(surfaceParams);
+            mSurfaceView
+                .requestLayout(); // Crucial for SurfaceView to redraw correctly
+          }
+        }
+      }
+
+      // Determine window corner for zoom anchor, considering margins
+      boolean isTop =
+          currentY < (screenHeight - MARGIN_TOP - MARGIN_BOTTOM) / 2 -
+                         currentHeight / 2 + MARGIN_TOP;
+      boolean isLeft =
+          currentX < (screenWidth - MARGIN_LEFT - MARGIN_RIGHT) / 2 -
+                         currentWidth / 2 + MARGIN_LEFT;
+
+      if (isLeft && isTop) { // Top-left
+        finalTargetX = MARGIN_LEFT;
+        finalTargetY = MARGIN_TOP;
+      } else if (!isLeft && isTop) { // Top-right
+        finalTargetX = screenWidth - targetWidth - MARGIN_RIGHT;
+        finalTargetY = MARGIN_TOP;
+      } else if (isLeft && !isTop) { // Bottom-left
+        finalTargetX = MARGIN_LEFT;
+        finalTargetY = screenHeight - targetHeight - MARGIN_BOTTOM;
+      } else { // Bottom-right
+        finalTargetX = screenWidth - targetWidth - MARGIN_RIGHT;
+        finalTargetY = screenHeight - targetHeight - MARGIN_BOTTOM;
+      }
+
+      // Ensure target position is within drawable area
+      finalTargetX = Math.max(
+          MARGIN_LEFT,
+          Math.min(finalTargetX, screenWidth - targetWidth - MARGIN_RIGHT));
+      finalTargetY = Math.max(
+          MARGIN_TOP,
+          Math.min(finalTargetY, screenHeight - targetHeight - MARGIN_BOTTOM));
+
+      final int finalTargetWidth = targetWidth;
+      final int finalTargetHeight = targetHeight;
+
+      // Make copies for use in animator listeners
+      final int animFinalTargetX = finalTargetX;
+      final int animFinalTargetY = finalTargetY;
+
+      ValueAnimator xAnimator = ValueAnimator.ofInt(currentX, finalTargetX);
+      xAnimator.setDuration(200);
+      xAnimator.addUpdateListener(animation -> {
+        mLayoutParams.x = (Integer)animation.getAnimatedValue();
+        mWindowManager.updateViewLayout(view, mLayoutParams);
+      });
+
+      ValueAnimator yAnimator = ValueAnimator.ofInt(currentY, finalTargetY);
+      yAnimator.setDuration(200);
+      yAnimator.addUpdateListener(animation -> {
+        mLayoutParams.y = (Integer)animation.getAnimatedValue();
+        mWindowManager.updateViewLayout(view, mLayoutParams);
+      });
+
+      ValueAnimator widthAnimator =
+          ValueAnimator.ofInt(currentWidth, finalTargetWidth);
+      widthAnimator.setDuration(200);
+      widthAnimator.addUpdateListener(animation -> {
+        mLayoutParams.width = (Integer)animation.getAnimatedValue();
+        if (mSurfaceView != null) { // Ensure mSurfaceView is not null
+          android.view.ViewGroup.LayoutParams surfaceParams =
+              mSurfaceView.getLayoutParams();
+          if (surfaceParams != null) { // Ensure surfaceParams is not null
+            surfaceParams.width = mLayoutParams.width;
+            mSurfaceView.setLayoutParams(surfaceParams);
+          }
+        }
+        mWindowManager.updateViewLayout(view, mLayoutParams);
+      });
+
+      ValueAnimator heightAnimator =
+          ValueAnimator.ofInt(currentHeight, finalTargetHeight);
+      heightAnimator.setDuration(200);
+      heightAnimator.addUpdateListener(animation -> {
+        mLayoutParams.height = (Integer)animation.getAnimatedValue();
+        if (mSurfaceView != null) { // Ensure mSurfaceView is not null
+          android.view.ViewGroup.LayoutParams surfaceParams =
+              mSurfaceView.getLayoutParams();
+          if (surfaceParams != null) { // Ensure surfaceParams is not null
+            surfaceParams.height = mLayoutParams.height;
+            mSurfaceView.setLayoutParams(surfaceParams);
+          }
+        }
+        mWindowManager.updateViewLayout(view, mLayoutParams);
+      });
+
+      android.animation.AnimatorSet animatorSet =
+          new android.animation.AnimatorSet();
+      animatorSet.playTogether(xAnimator, yAnimator, widthAnimator,
+                               heightAnimator);
+      // The isDoubleClickAnimating flag is now managed by
+      // FloatingOnTouchListener but we still need to set it within
+      // handleDoubleClick's AnimatorSet listeners to ensure it's active for the
+      // duration of this specific animation.
+      animatorSet.addListener(new android.animation.AnimatorListenerAdapter() {
+        @Override
+        public void onAnimationStart(android.animation.Animator animation) {
+          if (FloatingWindowService.this.mFloatingOnTouchListener != null) {
+            FloatingWindowService.this.mFloatingOnTouchListener
+                .isDoubleClickAnimating = true;
+          }
+          Log.d(TAG, "Double tap AnimatorSet started.");
+        }
+
+        @Override
+        public void onAnimationEnd(android.animation.Animator animation) {
+          if (FloatingWindowService.this.mFloatingOnTouchListener != null) {
+            FloatingWindowService.this.mFloatingOnTouchListener
+                .isDoubleClickAnimating = false;
+          }
+          // ValueAnimators update mLayoutParams continuously via their
+          // AnimatorUpdateListener. For safety, explicitly set final position
+          // values as the last update might not be exact.
+          mLayoutParams.x = animFinalTargetX;
+          mLayoutParams.y = animFinalTargetY;
+          // mLayoutParams.width and mLayoutParams.height should be at
+          // finalTargetWidth/Height due to widthAnimator and heightAnimator's
+          // updates.
+
+          // Perform a final update of the window layout with all parameters.
+          if (mSmallWindowView != null &&
+              mSmallWindowView.getWindowToken() != null) {
+            mWindowManager.updateViewLayout(mSmallWindowView, mLayoutParams);
+          }
+
+          // Resize SurfaceView (logic moved from postDelayed and refined)
+          if (mSurfaceView != null && mLayoutParams != null) {
+            android.view.ViewGroup.LayoutParams surfaceParams =
+                mSurfaceView.getLayoutParams();
+            if (surfaceParams != null) {
+              boolean changed = false;
+              if (surfaceParams.width != mLayoutParams.width) {
+                surfaceParams.width =
+                    mLayoutParams.width; // mLayoutParams.width is at its final
+                                         // animated value
+                changed = true;
+              }
+              if (surfaceParams.height != mLayoutParams.height) {
+                surfaceParams.height =
+                    mLayoutParams.height; // mLayoutParams.height is at its
+                                          // final animated value
+                changed = true;
+              }
+              if (changed) {
+                mSurfaceView.setLayoutParams(surfaceParams);
+              }
+              mSurfaceView
+                  .requestLayout(); // Ensure the SurfaceView redraws correctly
+              Log.d(TAG,
+                    "SurfaceView dimensions finalized in onAnimationEnd to: " +
+                        mLayoutParams.width + "x" + mLayoutParams.height);
+            }
+          }
+          Log.d(TAG, "Double tap AnimatorSet ended. Final state: x=" +
+                         mLayoutParams.x + ", y=" + mLayoutParams.y + ", w=" +
+                         mLayoutParams.width + ", h=" + mLayoutParams.height);
+        }
+
+        @Override
+        public void onAnimationCancel(android.animation.Animator animation) {
+          if (FloatingWindowService.this.mFloatingOnTouchListener != null) {
+            FloatingWindowService.this.mFloatingOnTouchListener
+                .isDoubleClickAnimating = false;
+          }
+          // Animation was cancelled, so explicitly set all mLayoutParams to
+          // their final target values.
+          mLayoutParams.x = animFinalTargetX;
+          mLayoutParams.y = animFinalTargetY;
+          mLayoutParams.width = finalTargetWidth;
+          mLayoutParams.height = finalTargetHeight;
+
+          if (mSmallWindowView != null &&
+              mSmallWindowView.getWindowToken() != null) {
+            mWindowManager.updateViewLayout(mSmallWindowView, mLayoutParams);
+          }
+
+          // Resize SurfaceView to final target dimensions
+          if (mSurfaceView != null && mLayoutParams != null) {
+            android.view.ViewGroup.LayoutParams surfaceParams =
+                mSurfaceView.getLayoutParams();
+            if (surfaceParams != null) {
+              if (surfaceParams.width != mLayoutParams.width ||
+                  surfaceParams.height != mLayoutParams.height) {
+                surfaceParams.width =
+                    mLayoutParams.width; // Now finalTargetWidth
+                surfaceParams.height =
+                    mLayoutParams.height; // Now finalTargetHeight
+                mSurfaceView.setLayoutParams(surfaceParams);
+              }
+              mSurfaceView
+                  .requestLayout(); // Ensure the SurfaceView redraws correctly
+            }
+          }
+          Log.d(TAG,
+                "Double tap AnimatorSet cancelled. State set to targets: x=" +
+                    mLayoutParams.x + ", y=" + mLayoutParams.y + ", w=" +
+                    mLayoutParams.width + ", h=" + mLayoutParams.height);
+        }
+      });
+      animatorSet.start();
+    }
+
+    private void animateSnapToEdge(View view) {
+      // Use pre-calculated screen metrics
+      // updateScreenMetrics(); // Ensure metrics are fresh if not updated in
+      // onTouch ACTION_DOWN Screen metrics are now updated in onTouch
+      // ACTION_DOWN, so they should be current here.
+      final int screenWidth = this.screenWidth; // Make final for use in lambda
+      final int windowWidthAtAnimationStart =
+          mLayoutParams.width; // Capture width at start
+
+      int currentX =
+          mLayoutParams
+              .x; // This is the x at the moment animateSnapToEdge is called
+      int targetX;
+
+      // Determine targetX based on current position and captured width
+      if (currentX + windowWidthAtAnimationStart / 2 < screenWidth / 2) {
+        targetX = MARGIN_LEFT;
+      } else {
+        targetX = screenWidth - windowWidthAtAnimationStart - MARGIN_RIGHT;
+      }
+
+      Log.i(TAG, "animateSnapToEdge: currentX=" + currentX +
+                     ", windowWidthAtAnimStart=" + windowWidthAtAnimationStart +
+                     ", screenWidth=" + screenWidth + ", calculatedTargetX=" +
+                     targetX + ", currentY=" + mLayoutParams.y +
+                     ", currentHeight=" + mLayoutParams.height);
+
+      if (currentX == targetX) {
+        Log.i(TAG, "animateSnapToEdge: Already at targetX (" + targetX +
+                       "). No animation needed.");
+        return;
+      }
+
+      ValueAnimator snapAnimator = ValueAnimator.ofInt(currentX, targetX);
+      snapAnimator.setDuration(200);
+      snapAnimator.addUpdateListener(animation -> {
+        mLayoutParams.x = (Integer)animation.getAnimatedValue();
+        // Boundary checks using width captured at animation start
+        if (mLayoutParams.x < 0) { // Physical screen boundary
+          mLayoutParams.x = 0;
+        }
+        // Ensure the right edge does not go beyond screen width
+        if (mLayoutParams.x + windowWidthAtAnimationStart >
+            screenWidth) { // Physical screen boundary
+          mLayoutParams.x = screenWidth - windowWidthAtAnimationStart;
+        }
+        try {
+          if (mSmallWindowView != null &&
+              mSmallWindowView.getWindowToken() !=
+                  null) { // Check if view is still attached
+            mWindowManager.updateViewLayout(view, mLayoutParams);
+          }
+        } catch (IllegalArgumentException e) {
+          Log.w(TAG, "animateSnapToEdge: View not attached? " + e.getMessage());
+          // Cancel animator if view is gone to prevent further errors
+          if (animation.isRunning()) {
+            animation.cancel();
+          }
+        }
+      });
+      snapAnimator.start();
+    }
   }
 }

package/lib/commonjs/index.js

@@ -6729,38 +6729,6 @@ var VeLivePlayerStatistics = function () {
             enumerable: false,
             configurable: true
         });
-        Object.defineProperty(VeLivePlayerStatistics_1.prototype, "format", {
-            /** {zh}
-             * @brief 当前播放的视频格式。
-             *
-             */
-            /** {en}
-             * @brief The video format.
-             *
-             */
-            get: function () {
-                // TODO: implement
-                throw new Error("not implement 'format'");
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(VeLivePlayerStatistics_1.prototype, "protocol", {
-            /** {zh}
-             * @brief 当前播放的传输协议。
-             *
-             */
-            /** {en}
-             * @brief The transmission protocol of the live stream.
-             *
-             */
-            get: function () {
-                // TODO: implement
-                throw new Error("not implement 'protocol'");
-            },
-            enumerable: false,
-            configurable: true
-        });
         Object.defineProperty(VeLivePlayerStatistics_1.prototype, "url", {
             /** {zh}
              * @brief 当前直播的播放地址。

package/lib/module/index.js

@@ -6727,38 +6727,6 @@ var VeLivePlayerStatistics = function () {
             enumerable: false,
             configurable: true
         });
-        Object.defineProperty(VeLivePlayerStatistics_1.prototype, "format", {
-            /** {zh}
-             * @brief 当前播放的视频格式。
-             *
-             */
-            /** {en}
-             * @brief The video format.
-             *
-             */
-            get: function () {
-                // TODO: implement
-                throw new Error("not implement 'format'");
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(VeLivePlayerStatistics_1.prototype, "protocol", {
-            /** {zh}
-             * @brief 当前播放的传输协议。
-             *
-             */
-            /** {en}
-             * @brief The transmission protocol of the live stream.
-             *
-             */
-            get: function () {
-                // TODO: implement
-                throw new Error("not implement 'protocol'");
-            },
-            enumerable: false,
-            configurable: true
-        });
         Object.defineProperty(VeLivePlayerStatistics_1.prototype, "url", {
             /** {zh}
              * @brief 当前直播的播放地址。

package/lib/typescript/codegen/pack/keytype.d.ts

@@ -111,18 +111,6 @@ export declare class VeLivePlayerStatistics {
      */
     get isHardwareDecode(): boolean;
     
-    /** {en}
-     * @brief The video format.
-     *
-     */
-    get format(): void;
-    
-    /** {en}
-     * @brief The transmission protocol of the live stream.
-     *
-     */
-    get protocol(): void;
-    
     /** {en}
      * @brief The current pull stream address.
      *

package/lib/typescript/core/keytype.d.ts

@@ -1 +1,17 @@
+declare module '../codegen/pack/keytype' {
+    interface VeLivePlayerStatistics {
+        
+        /** {en}
+         * @brief The video format.
+         *
+         */
+        format: VeLivePlayerFormat;
+        
+        /** {en}
+         * @brief The transmission protocol of the live stream.
+         *
+         */
+        protocol: VeLivePlayerProtocol;
+    }
+}
 export { VeLivePlayerAudioBufferType, VeLivePlayerAudioFrame, VeLivePlayerConfiguration, VeLivePlayerFillMode, VeLivePlayerFormat, VeLivePlayerLogLevel, VeLivePlayerMirror, VeLivePlayerPixelFormat, VeLivePlayerProtocol, VeLivePlayerResolution, VeLivePlayerResolutionSwitchReason, VeLivePlayerRotation, VeLivePlayerStatistics, VeLivePlayerStatus, VeLivePlayerStream, VeLivePlayerStreamData, VeLivePlayerStreamType, VeLivePlayerVideoBufferType, VeLivePlayerVideoFrame, } from '../codegen/pack/keytype';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byteplus/react-native-live-pull",
-  "version": "1.1.2-rc.2",
+  "version": "1.1.3-rc.0",
   "peerDependencies": {
     "react": "*",
     "react-native": "*"