Android 如何使用最小值和最大值放大布局

我有以下功能，可以无限放大和缩小，但是我正在尝试为缩放设置

min

和

max

值，以便布局不会太大或太小。我已经尝试过使用，但我不明白在代码中应该放在哪里

private static final float MIN_ZOOM = 1.0f;
private static final float MAX_ZOOM = //set Maximum zooming level
float scale = Math.max(MIN_ZOOM, Math.min(scale, MAX_ZOOM));

public class ZoomableView extends RelativeLayout {

    // States.
    private static final byte NONE = 0;
    private static final byte DRAG = 1;
    private static final byte ZOOM = 2;

    private byte mode = NONE;

    // Matrices used to move and zoom image.
    private Matrix matrix = new Matrix();
    private Matrix matrixInverse = new Matrix();
    private Matrix savedMatrix = new Matrix();

    // Parameters for zooming.
    private PointF start = new PointF();
    private PointF mid = new PointF();
    private float oldDist = 1f;
    private float[] lastEvent = null;
    private long lastDownTime = 0l;

    private float[] mDispatchTouchEventWorkingArray = new float[2];
    private float[] mOnTouchEventWorkingArray = new float[2];


    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        mDispatchTouchEventWorkingArray[0] = ev.getX();
        mDispatchTouchEventWorkingArray[1] = ev.getY();
        mDispatchTouchEventWorkingArray = screenPointsToScaledPoints(mDispatchTouchEventWorkingArray);
        ev.setLocation(mDispatchTouchEventWorkingArray[0], mDispatchTouchEventWorkingArray[1]);
        return super.dispatchTouchEvent(ev);
    }

    public ZoomableView(Context context) {
        super(context);
        init(context);
    }

    public ZoomableView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    public ZoomableView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context);
    }


    private void init(Context context) {

    }


    /**
     * Determine the space between the first two fingers
     */
    private float spacing(MotionEvent event) {
        float x = event.getX(0) - event.getX(1);
        float y = event.getY(0) - event.getY(1);
        return (float) Math.sqrt(x * x + y * y);
    }

    /**
     * Calculate the mid point of the first two fingers
     */
    private void midPoint(PointF point, MotionEvent event) {
        float x = event.getX(0) + event.getX(1);
        float y = event.getY(0) + event.getY(1);
        point.set(x / 2, y / 2);
    }

    private float[] scaledPointsToScreenPoints(float[] a) {
        matrix.mapPoints(a);
        return a;
    }

    private float[] screenPointsToScaledPoints(float[] a) {
        matrixInverse.mapPoints(a);
        return a;
    }


    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            View child = getChildAt(i);
            if (child.getVisibility() != GONE) {
                child.layout(left, top, left + child.getMeasuredWidth(), top + child.getMeasuredHeight());
            }
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

        int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            View child = getChildAt(i);
            if (child.getVisibility() != GONE) {
                measureChild(child, widthMeasureSpec, heightMeasureSpec);
            }
        }
    }

    @Override
    protected void dispatchDraw(Canvas canvas) {
        float[] values = new float[9];
        matrix.getValues(values);
        canvas.save();
        canvas.translate(values[Matrix.MTRANS_X], values[Matrix.MTRANS_Y]);
        canvas.scale(values[Matrix.MSCALE_X], values[Matrix.MSCALE_Y]);
        super.dispatchDraw(canvas);
        canvas.restore();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // handle touch events here
        mOnTouchEventWorkingArray[0] = event.getX();
        mOnTouchEventWorkingArray[1] = event.getY();

        mOnTouchEventWorkingArray = scaledPointsToScreenPoints(mOnTouchEventWorkingArray);

        event.setLocation(mOnTouchEventWorkingArray[0], mOnTouchEventWorkingArray[1]);

        switch (event.getAction() & MotionEvent.ACTION_MASK) {
            case MotionEvent.ACTION_DOWN:
                savedMatrix.set(matrix);
                mode = DRAG;
                lastEvent = null;
                long downTime = event.getDownTime();
                if (downTime - lastDownTime < 300l) {
                    float density = getResources().getDisplayMetrics().density;
                    if (Math.max(Math.abs(start.x - event.getX()), Math.abs(start.y - event.getY())) < 40.f * density) {
                        savedMatrix.set(matrix);
                        mid.set(event.getX(), event.getY());
                        mode = ZOOM;
                        lastEvent = new float[4];
                        lastEvent[0] = lastEvent[1] = event.getX();
                        lastEvent[2] = lastEvent[3] = event.getY();
                    }
                    lastDownTime = 0l;
                } else {
                    lastDownTime = downTime;
                }
                start.set(event.getX(), event.getY());
                break;
            case MotionEvent.ACTION_POINTER_DOWN:
                oldDist = spacing(event);
                if (oldDist > 10f) {
                    savedMatrix.set(matrix);
                    midPoint(mid, event);
                    mode = ZOOM;
                }
                lastEvent = new float[4];
                lastEvent[0] = event.getX(0);
                lastEvent[1] = event.getX(1);
                lastEvent[2] = event.getY(0);
                lastEvent[3] = event.getY(1);
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_POINTER_UP:
                mode = NONE;
                lastEvent = null;
                break;
            case MotionEvent.ACTION_MOVE:
                final float density = getResources().getDisplayMetrics().density;
                if (mode == DRAG) {
                    matrix.set(savedMatrix);
                    float dx = event.getX() - start.x;
                    float dy = event.getY() - start.y;
                    matrix.postTranslate(dx, dy);
                    matrix.invert(matrixInverse);
                    if (Math.max(Math.abs(start.x - event.getX()), Math.abs(start.y - event.getY())) > 20.f * density) {
                        lastDownTime = 0l;
                    }
                } else if (mode == ZOOM) {
                    if (event.getPointerCount() > 1) {
                        float newDist = spacing(event);
                        if (newDist > 10f * density) {
                            matrix.set(savedMatrix);
                            float scale = (newDist / oldDist);
                            matrix.postScale(scale, scale, mid.x, mid.y);
                            matrix.invert(matrixInverse);
                        }
                    } else {
                        matrix.set(savedMatrix);
                        float scale = event.getY() / start.y;
                        matrix.postScale(scale, scale, mid.x, mid.y);
                        matrix.invert(matrixInverse);
                    }
                }
                break;
        }

        invalidate();
        return true;
    }


}

private static final float MIN_ZOOM=1.0f；
私有静态最终浮点最大值\u缩放=//设置最大缩放级别
浮动比例=数学最大值（最小缩放，数学最小值（缩放，最大缩放））；
公共类ZoomableView扩展了RelativeLayout{
//国家。
私有静态最终字节NONE=0；
私有静态最终字节拖拽=1；
私有静态最终字节缩放=2；
专用字节模式=无；
//用于移动和缩放图像的矩阵。
私有矩阵=新矩阵（）；
私有矩阵matrixInverse=新矩阵（）；
私有矩阵savedMatrix=新矩阵（）；
//用于缩放的参数。
private PointF start=new PointF（）；
私有点f mid=新点f（）；
私有浮动oldDist=1f；
私有浮点[]lastEvent=null；
私人长时间停机时间=0l；
私有浮动[]mDispatchTouchEventWorkingArray=新浮动[2]；
私有浮动[]mOnTouchEventWorkingArray=新浮动[2]；
@凌驾
公共布尔dispatchTouchEvent（MotionEvent ev）{
mDispatchTouchEventWorkingArray[0]=ev.getX（）；
mDispatchTouchEventWorkingArray[1]=ev.getY（）；
mDispatchTouchEventWorkingArray=屏幕点到缩放点（mDispatchTouchEventWorkingArray）；
ev.setLocation（mDispatchTouchEventWorkingArray[0]，mDispatchTouchEventWorkingArray[1]）；
返回超级dispatchTouchEvent（ev）；
}
公共缩放视图（上下文）{
超级（上下文）；
init（上下文）；
}
公共ZoomableView（上下文、属性集属性）{
超级（上下文，attrs）；
init（上下文）；
}
公共ZoomableView（上下文、属性集属性、int defStyleAttr）{
super（上下文、attrs、defStyleAttr）；
init（上下文）；
}
私有void init（上下文）{
}
/**
*确定前两个手指之间的间距
*/
专用浮动间距（MotionEvent事件）{
float x=event.getX（0）-event.getX（1）；
float y=event.getY（0）-event.getY（1）；
返回（浮点）数学sqrt（x*x+y*y）；
}
/**
*计算前两个手指的中点
*/
专用空心中点（点F点、MotionEvent事件）{
float x=event.getX（0）+event.getX（1）；
float y=event.getY（0）+event.getY（1）；
点集（x/2，y/2）；
}
专用浮点[]缩放点到屏幕点（浮点[]a）{
矩阵.地图点（a）；
返回a；
}
专用浮点[]屏幕点缩放点（浮点[]a）{
matrixInverse.地图点（a）；
返回a；
}
@凌驾
仅限受保护的空心布局（布尔值已更改、整数左侧、整数顶部、整数右侧、整数底部）{
int childCount=getChildCount（）；
for（int i=0；i10f）{
savedMatrix.set（矩阵）；
中点（中点，事件）；
模式=缩放；
}
lastEvent=新浮点[4]；
lastEvent[0]=event.getX（0）；
lastEvent[1]=event.getX（1）；
public class ZoomableView extends RelativeLayout {

@Override
public int getMaxZoomLevel() {
    return 22;
}

@Override
public int getMinZoomLevel() {
    return 12;
}

}