双指放大页面后会自动缩小

[wizos]

RT，目前发下在miui11上存在该问题，其他设备情况未知。NestedScrollAgentWebView 类建议采用以下代码，实测可以解决该问题，且没有引发新问题。

public class NestedScrollAgentWebView extends AgentWebView implements NestedScrollingChild {

/***
 * 方法一
 * https://github.com/fashare2015/NestedScrollWebView
 */
public NestedScrollAgentWebView(Context context) {
    super(context);
    initView();
}

private static final int INVALID_POINTER = -1;

private void initView() {
    mChildHelper = new NestedScrollingChildHelper(this);
    setNestedScrollingEnabled(true);
}


/**
 * Position of the last motion event.
 */
private int mLastMotionY;

/**
 * ID of the active pointer. This is used to retain consistency during
 * drags/flings if multiple pointers are used.
 */
private int mActivePointerId = INVALID_POINTER;

/**
 * Used during scrolling to retrieve the new offset within the window.
 */
private final int[] mScrollOffset = new int[2];
private final int[] mScrollConsumed = new int[2];
private NestedScrollingChildHelper mChildHelper;
boolean mIsBeingDragged;


@Override
public boolean onTouchEvent(MotionEvent ev) {
    final int actionMasked = ev.getActionMasked();

    switch (actionMasked) {
        case MotionEvent.ACTION_DOWN:
            mIsBeingDragged = false;

            // Remember where the motion event started
            mLastMotionY = (int) ev.getY();

            mActivePointerId = ev.getPointerId(0);
            startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
            break;

        case MotionEvent.ACTION_MOVE:
            final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
            if (activePointerIndex == -1) {
                break;
            }

            final int y = (int) ev.getY(activePointerIndex);
            int deltaY = mLastMotionY - y;
            if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset)) {
                deltaY -= mScrollConsumed[1];
            }
            // Scroll to follow the motion event
            mLastMotionY = y - mScrollOffset[1];

            final int oldY = getScrollY();
            final int scrolledDeltaY = Math.max(0, oldY + deltaY) - oldY;
            final int unconsumedY = deltaY - scrolledDeltaY;
            if (dispatchNestedScroll(0, scrolledDeltaY, 0, unconsumedY, mScrollOffset)) {
                mLastMotionY -= mScrollOffset[1];
            }
            break;
        case MotionEvent.ACTION_UP:
            mActivePointerId = INVALID_POINTER;
            endDrag();
            break;
        case MotionEvent.ACTION_CANCEL:
            mActivePointerId = INVALID_POINTER;
            endDrag();
            break;
        case MotionEvent.ACTION_POINTER_DOWN: {
            final int index = ev.getActionIndex();
            mLastMotionY = (int) ev.getY(index);
            mActivePointerId = ev.getPointerId(index);
            break;
        }
        case MotionEvent.ACTION_POINTER_UP:
            onSecondaryPointerUp(ev);
            mLastMotionY = (int) ev.getY(ev.findPointerIndex(mActivePointerId));
            break;
        default:
            break;
    }
    return super.onTouchEvent(ev);
}

private void endDrag() {
    mIsBeingDragged = false;
    stopNestedScroll();
}

private void onSecondaryPointerUp(MotionEvent ev) {
    final int pointerIndex = ev.getActionIndex();
    final int pointerId = ev.getPointerId(pointerIndex);
    if (pointerId == mActivePointerId) {
        // This was our active pointer going up. Choose a new
        // active pointer and adjust accordingly.
        // TODO: Make this decision more intelligent.
        final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
        mLastMotionY = (int) ev.getY(newPointerIndex);
        mActivePointerId = ev.getPointerId(newPointerIndex);
    }
}


@Override
public void setNestedScrollingEnabled(boolean enabled) {
    mChildHelper.setNestedScrollingEnabled(enabled);
}

@Override
public boolean isNestedScrollingEnabled() {
    return mChildHelper.isNestedScrollingEnabled();
}

@Override
public boolean startNestedScroll(int axes) {
    return mChildHelper.startNestedScroll(axes);
}

@Override
public void stopNestedScroll() {
    mChildHelper.stopNestedScroll();
}

@Override
public boolean hasNestedScrollingParent() {
    return mChildHelper.hasNestedScrollingParent();
}

@Override
public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow) {
    return mChildHelper.dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, offsetInWindow);
}

@Override
public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
    return mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow);
}

@Override
public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {
    return mChildHelper.dispatchNestedFling(velocityX, velocityY, consumed);
}

@Override
public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
    return mChildHelper.dispatchNestedPreFling(velocityX, velocityY);
}

}