Android代码中给我们提供大量的帮助类来方便我们的使用。今天咱们就来看下手势帮助类GestureDetector、ScaleGestureDetector。

一、GestureDetector

Android手机屏幕上，当咱们触摸屏幕的时候，会产生许多手势事件，如down，up，scroll，filing等等。咱们可以在onTouchEvent()方法里面完成各种手势识别。但是，咱们自己去识别各种手势就比较麻烦了，而且有些情况可能考虑的不是那么的全面。所以，为了方便咱们的时候Android就给提供了GestureDetector帮助类来方便大家的使用。

GestureDetector类给我们提供了三个接口，一个外部类。

OnGestureListener：接口，用来监听手势事件(6种)。
OnDoubleTapListener：接口，用来监听双击事件。
OnContextClickListener：接口，外接设备，比如外接鼠标产生的事件(本文中我们不考虑)。
SimpleOnGestureListener：外部类，SimpleOnGestureListener其实上面三个接口中所有函数的集成，它包含了这三个接口里所有必须要实现的函数而且都已经重写，但所有方法体都是空的。需要自己根据情况去重写。

OnGestureListener接口方法解释：

    public interface OnGestureListener {        /**         * 按下。返回值表示事件是否处理         */        boolean onDown(MotionEvent e);        /**         * 短按(手指尚未松开也没有达到scroll条件)         */        void onShowPress(MotionEvent e);        /**         * 轻触(手指松开)         */        boolean onSingleTapUp(MotionEvent e);        /**         * 滑动(一次完整的事件可能会多次触发该函数)。返回值表示事件是否处理         */        boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY);        /**         * 长按(手指尚未松开也没有达到scroll条件)         */        void onLongPress(MotionEvent e);        /**         * 滑屏(用户按下触摸屏、快速滑动后松开，返回值表示事件是否处理)         */        boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY);    }

OnDoubleTapListener接口方法解释：

    public interface OnDoubleTapListener {        /**         * 单击事件(onSingleTapConfirmed，onDoubleTap是两个互斥的函数)         */        boolean onSingleTapConfirmed(MotionEvent e);        /**         * 双击事件         */        boolean onDoubleTap(MotionEvent e);        /**         * 双击事件产生之后手指还没有抬起的时候的后续事件         */        boolean onDoubleTapEvent(MotionEvent e);    }

SimpleOnGestureListener实现了OnGestureListener、OnDoubleTapListener、OnContextClickListener。SimpleOnGestureListener里面的方法是是三个接口的集合。

1.1、GestureDetector使用

GestureDetector的使用非常的简单，分为三个步骤：
- 定义GestureDetector类，
- 将touch事件交给GestureDetector(onTouchEvent函数里面调用GestureDetector的onTouchEvent函数)。
- 处理SimpleOnGestureListener或者OnGestureListener、OnDoubleTapListener、OnContextClickListener三者之一的回调。

我们用一个简单的实例来说明GestureDetector的使用。我就简单的写一个View，然后看看各个事件的触发情况。

public class GestureView extends View {    //定义GestureDetector类    private GestureDetector mGestureDetector;    public GestureView(Context context) {        this(context, null);    }    public GestureView(Context context, @Nullable AttributeSet attrs) {        this(context, attrs, 0);    }    public GestureView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {        super(context, attrs, defStyleAttr);        mGestureDetector = new GestureDetector(context, mOnGestureListener);    }    @Override    public boolean onTouchEvent(MotionEvent event) {        return mGestureDetector.onTouchEvent(event);    }    private final GestureDetector.OnGestureListener mOnGestureListener = new GestureDetector.SimpleOnGestureListener() {        @Override        public boolean onSingleTapUp(MotionEvent e) {            Log.d("tuacy", "onSingleTapUp");            return true;        }        @Override        public void onLongPress(MotionEvent e) {            Log.d("tuacy", "onLongPress");            super.onLongPress(e);        }        @Override        public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {            Log.d("tuacy", "onScroll");            return true;        }        @Override        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {            Log.d("tuacy", "onFling");            return true;        }        @Override        public void onShowPress(MotionEvent e) {            Log.d("tuacy", "onShowPress");            super.onShowPress(e);        }        @Override        public boolean onDown(MotionEvent e) {            Log.d("tuacy", "onDown");            return true;        }        @Override        public boolean onDoubleTap(MotionEvent e) {            Log.d("tuacy", "onDoubleTap");            return true;        }        @Override        public boolean onDoubleTapEvent(MotionEvent e) {            Log.d("tuacy", "onDoubleTapEvent");            return true;        }        @Override        public boolean onSingleTapConfirmed(MotionEvent e) {            Log.d("tuacy", "onSingleTapConfirmed");            return true;        }    };}

我们总结下各个动作对应的回调

快速点击下View：onDow() -> onSingleTapUp() -> onSingleTapConfirmed()。
短按View不滑动：onDown() -> onShowPress() -> onSingleTapUp() -> onSingleTapConfirmed()。
长按View不滑动：onDown() -> onShowPress() -> onLongPress()。
滑动：onDown() -> onScroll() -> onScroll()….。
快速滑动：onDown() -> onScroll() -> onScroll()…. -> onFling()。
快速点击两下：onDown() -> onSingleTapUp() -> onDoubleTap() -> onDoubleTapEvent() -> onDoubleTapEvent()…。

GestureDetector的使用给一个建议，GestureDetector的所有回调函数，有返回值的。如果你用到了就返回true。因为有些函数你不返回true的话可能后续的事件传递不进来。这里我们可以给大家留一个问题，大家可以自己分下下返回false的情况对应的回调顺序。比如onDown()函数我们返回false，快速点击的时候回调调用的情况。

1.2、GestureDetector源码解析

GestureDetector源码也不是很复杂，我们做一个非常简单的分析。我们从构造函数开始。

    public GestureDetector(Context context, OnGestureListener listener) {        this(context, listener, null);    }    public GestureDetector(Context context, OnGestureListener listener, Handler handler) {        if (handler != null) {            mHandler = new GestureHandler(handler);        } else {            mHandler = new GestureHandler();        }        mListener = listener;        if (listener instanceof OnDoubleTapListener) {            setOnDoubleTapListener((OnDoubleTapListener) listener);        }        if (listener instanceof OnContextClickListener) {            setContextClickListener((OnContextClickListener) listener);        }        init(context);    }    private void init(Context context) {        if (mListener == null) {            throw new NullPointerException("OnGestureListener must not be null");        }        mIsLongpressEnabled = true;        // Fallback to support pre-donuts releases        int touchSlop, doubleTapSlop, doubleTapTouchSlop;        if (context == null) {            //noinspection deprecation            touchSlop = ViewConfiguration.getTouchSlop();            doubleTapTouchSlop = touchSlop; // Hack rather than adding a hiden method for this            doubleTapSlop = ViewConfiguration.getDoubleTapSlop();            //noinspection deprecation            mMinimumFlingVelocity = ViewConfiguration.getMinimumFlingVelocity();            mMaximumFlingVelocity = ViewConfiguration.getMaximumFlingVelocity();        } else {            final ViewConfiguration configuration = ViewConfiguration.get(context);            touchSlop = configuration.getScaledTouchSlop();            doubleTapTouchSlop = configuration.getScaledDoubleTapTouchSlop();            doubleTapSlop = configuration.getScaledDoubleTapSlop();            mMinimumFlingVelocity = configuration.getScaledMinimumFlingVelocity();            mMaximumFlingVelocity = configuration.getScaledMaximumFlingVelocity();        }        mTouchSlopSquare = touchSlop * touchSlop;        mDoubleTapTouchSlopSquare = doubleTapTouchSlop * doubleTapTouchSlop;        mDoubleTapSlopSquare = doubleTapSlop * doubleTapSlop;    }

GestureDetector构造函数里面的代码也不复杂，都是在设置一些变量。其中mHandler：用于sendMessage，mListener、mDoubleTapListener、mContextClickListener：三个接口的变量，mIsLongpressEnabled：是否支持长按操作，mMinimumFlingVelocity：fling的最小速度，mMaximumFlingVelocity：fling的最大速度，mTouchSlopSquare：用来判断是否开始scroll，mDoubleTapTouchSlopSquare：判断双击的时候用到，第一个单击的时候产生了MotionEvent.ACTION_MOVE，并且move的距离超过了这个值就不认为是双击事件，mDoubleTapSlopSquare：判断双击的时候用到，两次单击范围要在这个值之内。否则不算是双击事件。

分析完GestureDetector的构造函数，接下来我们直接看GestureDetector的onTouchEvent()函数，这个函数我们主要分析：MotionEvent.ACTION_DOWN、MotionEvent.ACTION_MOVE、MotionEvent.ACTION_UP三个事件的处理过程。

    public boolean onTouchEvent(MotionEvent ev) {        // 这一部分是用于测试的，我们不用管        if (mInputEventConsistencyVerifier != null) {            mInputEventConsistencyVerifier.onTouchEvent(ev, 0);        }        final int action = ev.getAction();        // 用来记录滑动速度        if (mVelocityTracker == null) {            mVelocityTracker = VelocityTracker.obtain();        }        mVelocityTracker.addMovement(ev);        ...        boolean handled = false;        switch (action & MotionEvent.ACTION_MASK) {            ...            case MotionEvent.ACTION_DOWN:                if (mDoubleTapListener != null) {                    boolean hadTapMessage = mHandler.hasMessages(TAP);                    if (hadTapMessage) mHandler.removeMessages(TAP);                    if ((mCurrentDownEvent != null) && (mPreviousUpEvent != null) && hadTapMessage &&                        isConsideredDoubleTap(mCurrentDownEvent, mPreviousUpEvent, ev)) {                        // This is a second tap                        mIsDoubleTapping = true;                        // Give a callback with the first tap of the double-tap                        handled |= mDoubleTapListener.onDoubleTap(mCurrentDownEvent);                        // Give a callback with down event of the double-tap                        handled |= mDoubleTapListener.onDoubleTapEvent(ev);                    } else {                        // This is a first tap                        mHandler.sendEmptyMessageDelayed(TAP, DOUBLE_TAP_TIMEOUT);                    }                }                mDownFocusX = mLastFocusX = focusX;                mDownFocusY = mLastFocusY = focusY;                if (mCurrentDownEvent != null) {                    mCurrentDownEvent.recycle();                }                mCurrentDownEvent = MotionEvent.obtain(ev);                mAlwaysInTapRegion = true;                mAlwaysInBiggerTapRegion = true;                mStillDown = true;                mInLongPress = false;                mDeferConfirmSingleTap = false;                // 用于处理长按事件处理 对应onLongPress()函数                if (mIsLongpressEnabled) {                    mHandler.removeMessages(LONG_PRESS);                    mHandler.sendEmptyMessageAtTime(LONG_PRESS,                                                    mCurrentDownEvent.getDownTime() + LONGPRESS_TIMEOUT);                }                // 用于轻触事件处理，对应onShowPress()函数                mHandler.sendEmptyMessageAtTime(SHOW_PRESS,                                                mCurrentDownEvent.getDownTime() + TAP_TIMEOUT);                handled |= mListener.onDown(ev);                break;            case MotionEvent.ACTION_MOVE:                if (mInLongPress || mInContextClick) {                    break;                }                final float scrollX = mLastFocusX - focusX;                final float scrollY = mLastFocusY - focusY;                if (mIsDoubleTapping) {                    // Give the move events of the double-tap                    handled |= mDoubleTapListener.onDoubleTapEvent(ev);                } else if (mAlwaysInTapRegion) {                    final int deltaX = (int) (focusX - mDownFocusX);                    final int deltaY = (int) (focusY - mDownFocusY);                    int distance = (deltaX * deltaX) + (deltaY * deltaY);                    int slopSquare = isGeneratedGesture ? 0 : mTouchSlopSquare;                    if (distance > slopSquare) {                        handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);                        mLastFocusX = focusX;                        mLastFocusY = focusY;                        mAlwaysInTapRegion = false;                        mHandler.removeMessages(TAP);                        mHandler.removeMessages(SHOW_PRESS);                        mHandler.removeMessages(LONG_PRESS);                    }                    int doubleTapSlopSquare = isGeneratedGesture ? 0 : mDoubleTapTouchSlopSquare;                    if (distance > doubleTapSlopSquare) {                        mAlwaysInBiggerTapRegion = false;                    }                } else if ((Math.abs(scrollX) >= 1) || (Math.abs(scrollY) >= 1)) {                    handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);                    mLastFocusX = focusX;                    mLastFocusY = focusY;                }                break;            case MotionEvent.ACTION_UP:                mStillDown = false;                MotionEvent currentUpEvent = MotionEvent.obtain(ev);                if (mIsDoubleTapping) {                    // Finally, give the up event of the double-tap                    handled |= mDoubleTapListener.onDoubleTapEvent(ev);                } else if (mInLongPress) {                    mHandler.removeMessages(TAP);                    mInLongPress = false;                } else if (mAlwaysInTapRegion && !mIgnoreNextUpEvent) {                    handled = mListener.onSingleTapUp(ev);                    if (mDeferConfirmSingleTap && mDoubleTapListener != null) {                        mDoubleTapListener.onSingleTapConfirmed(ev);                    }                } else if (!mIgnoreNextUpEvent) {                    // A fling must travel the minimum tap distance                    final VelocityTracker velocityTracker = mVelocityTracker;                    final int pointerId = ev.getPointerId(0);                    velocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity);                    final float velocityY = velocityTracker.getYVelocity(pointerId);                    final float velocityX = velocityTracker.getXVelocity(pointerId);                    if ((Math.abs(velocityY) > mMinimumFlingVelocity)                        || (Math.abs(velocityX) > mMinimumFlingVelocity)){                        handled = mListener.onFling(mCurrentDownEvent, ev, velocityX, velocityY);                    }                }                if (mPreviousUpEvent != null) {                    mPreviousUpEvent.recycle();                }                // Hold the event we obtained above - listeners may have changed the original.                mPreviousUpEvent = currentUpEvent;                if (mVelocityTracker != null) {                    // This may have been cleared when we called out to the                    // application above.                    mVelocityTracker.recycle();                    mVelocityTracker = null;                }                mIsDoubleTapping = false;                mDeferConfirmSingleTap = false;                mIgnoreNextUpEvent = false;                mHandler.removeMessages(SHOW_PRESS);                mHandler.removeMessages(LONG_PRESS);                break;            case MotionEvent.ACTION_CANCEL:                cancel();                break;        }        if (!handled && mInputEventConsistencyVerifier != null) {            mInputEventConsistencyVerifier.onUnhandledEvent(ev, 0);        }        return handled;    }

MotionEvent.ACTION_DOWN处理部分我们分四个部分来看：

对DoubleTapListener做处理：DoubleTapListener是用于处理双击事件，所以肯定是要有前后两个事件的，我们可以看下大概的逻辑mCurrentDownEvent是前一次事件按下时候的MotionEvent，mPreviousUpEvent是前一次事件抬起是的的MotionEvent。从这段代码我们也能发现onSingleTapConfirmed()函数和onDoubleTap()两个函数是互斥的。其中isConsideredDoubleTap()函数是用于判断是否达到了双击事件的条件。mIsDoubleTapping表示产生了双击事件。
长按事件的处理，mHandler.sendEmptyMessageAtTime(LONG_PRESS,
mCurrentDownEvent.getDownTime() + LONGPRESS_TIMEOUT); 发送了一个LONG_PRESS类型的延时message。至于长按事件会不会触发，就要看LONG_PRESS对应的message在LONGPRESS_TIMEOUT时间内会不会被remove掉。
轻触事件的处理，mHandler.sendEmptyMessageAtTime(SHOW_PRESS,
mCurrentDownEvent.getDownTime() + TAP_TIMEOUT);发送了一个SHOW_PRESS类型的延时message。同样轻触事件会不会触发也的看后续SHOW_PRESS对应的message会不会被remove掉。
调用onDown()函数，handled |= mListener.onDown(ev);

MotionEvent.ACTION_DOWN的时候我们还得关注下返回值，只有返回true才能保证后续事件在进入到onTouchEvent()函数里面来。

MotionEvent.ACTION_MOVE处理部分

MotionEvent.ACTION_MOVE部分逻辑处理。一开始判断是否产生了长按事件，产生了长按事件直接break掉。接下来关键点在里面的if else。mIsDoubleTapping:表示产生了双击事件，mAlwaysInTapRegion:表示是否进入了滑动状态。从逻辑处理过程可以看到产生了滑动事件就会把TAP，SHOW_PRESS，LONG_PRESS对应的消息都移除掉。

MotionEvent.ACTION_UP处理部分

MotionEvent.ACTION_UP的逻辑也不难，如果产生了双击事件就回调onDoubleTapEvent()函数，如果还没有进入滑动的状态就回调onSingleTapUp()，然后再看要不要回调onSingleTapConfirmed()函数，这里咱们也能发现产生了双击事件就不会回调onSingleTapConfirmed()函数。最后就是onFling()函数的回调。

二、ScaleGestureDetector

ScaleGestureDetector是用于处理缩放的工具类，用法与GestureDetector类似，都是通过onTouchEvent()关联相应的MotionEvent事件。

ScaleGestureDetector类给提供了OnScaleGestureListener接口，来告诉我们缩放的过程中的一些回调。

OnScaleGestureListener回调函数介绍

    public interface OnScaleGestureListener {        /**         * 缩放进行中，返回值表示是否下次缩放需要重置，如果返回ture，那么detector就会重置缩放事件，如果返回false，detector会在之前的缩放上继续进行计算         */        public boolean onScale(ScaleGestureDetector detector);        /**         * 缩放开始，返回值表示是否受理后续的缩放事件         */        public boolean onScaleBegin(ScaleGestureDetector detector);        /**         * 缩放结束         */        public void onScaleEnd(ScaleGestureDetector detector);    }

ScaleGestureDetector类常用函数介绍，因为在缩放的过程中，要通过ScaleGestureDetector来获取一些缩放信息。

    /**     * 缩放是否正处在进行中     */    public boolean isInProgress();    /**     * 返回组成缩放手势(两个手指)中点x的位置     */    public float getFocusX();    /**     * 返回组成缩放手势(两个手指)中点y的位置     */    public float getFocusY();    /**     * 组成缩放手势的两个触点的跨度(两个触点间的距离)     */    public float getCurrentSpan();    /**     * 同上，x的距离     */    public float getCurrentSpanX();    /**     * 同上，y的距离     */    public float getCurrentSpanY();    /**     * 组成缩放手势的两个触点的前一次缩放的跨度(两个触点间的距离)     */    public float getPreviousSpan();    /**     * 同上，x的距离     */    public float getPreviousSpanX();    /**     * 同上，y的距离     */    public float getPreviousSpanY();    /**     * 获取本次缩放事件的缩放因子,缩放事件以onScale()返回值为基准，一旦该方法返回true，代表本次事件结束，重新开启下次缩放事件。     */    public float getScaleFactor();    /**     * 返回上次缩放事件结束时到当前的时间间隔     */    public long getTimeDelta();    /**     * 获取当前motion事件的时间     */    public long getEventTime();

2.1、ScaleGestureDetector使用

ScaleGestureDetector的使用也是简单的分为三步。
- 定义ScaleGestureDetector类，
- 将touch事件交给ScaleGestureDetector(onTouchEvent函数里面调用ScaleGestureDetector的onTouchEvent函数)。
- 处理OnScaleGestureListener各个回调。

接下来我们通过重写ImageView，使用ScaleGestureDetector来实现图片的缩放功能。

代码是网上找的

public class ScaleImageView extends AppCompatImageView    implements ScaleGestureDetector.OnScaleGestureListener, ViewTreeObserver.OnGlobalLayoutListener {    private static final int MAX_SCALE_TIME = 4;    private ScaleGestureDetector mScaleGestureDetector;    // 缩放工具类    private Matrix               mMatrix;    private boolean              mFirstLayout;    private float                mBaseScale;    public ScaleImageView(Context context) {        this(context, null);    }    public ScaleImageView(Context context, AttributeSet attrs) {        this(context, attrs, 0);    }    public ScaleImageView(Context context, AttributeSet attrs, int defStyleAttr) {        super(context, attrs, defStyleAttr);        mScaleGestureDetector = new ScaleGestureDetector(context, this);        mMatrix = new Matrix();        setScaleType(ScaleType.MATRIX);        mFirstLayout = true;    }    @Override    protected void onAttachedToWindow() {        super.onAttachedToWindow();        getViewTreeObserver().addOnGlobalLayoutListener(this);    }    @Override    protected void onDetachedFromWindow() {        super.onDetachedFromWindow();        //移除OnGlobalLayoutListener        getViewTreeObserver().removeGlobalOnLayoutListener(this);    }    @Override    public boolean onTouchEvent(MotionEvent event) {        return mScaleGestureDetector.onTouchEvent(event);    }    /**     * 缩放进行中     */    @Override    public boolean onScale(ScaleGestureDetector detector) {        if (null == getDrawable() || mMatrix == null) {            return true;        }        // 获取缩放因子        float scaleFactor = detector.getScaleFactor();        float scale = getScale();        // 控件图片的缩放范围        if ((scale < mBaseScale * MAX_SCALE_TIME && scaleFactor > 1.0f) || (scale > mBaseScale && scaleFactor < 1.0f)) {            if (scale * scaleFactor < mBaseScale) {                scaleFactor = mBaseScale / scale;            }            if (scale * scaleFactor > mBaseScale * MAX_SCALE_TIME) {                scaleFactor = mBaseScale * MAX_SCALE_TIME / scale;            }            // 以屏幕中央位置进行缩放            mMatrix.postScale(scaleFactor, scaleFactor, detector.getFocusX(), detector.getFocusY());            borderAndCenterCheck();            setImageMatrix(mMatrix);        }        return false;    }    /**     * 缩放开始     */    @Override    public boolean onScaleBegin(ScaleGestureDetector detector) {        return true;    }    /**     * 缩放结束     */    @Override    public void onScaleEnd(ScaleGestureDetector detector) {    }    @Override    public void onGlobalLayout() {        if (mFirstLayout) {            mFirstLayout = false;            // 获取控件的宽度和高度            int viewWidth = getWidth();            int viewHeight = getHeight();            // 获取到ImageView对应图片的宽度和高度            Drawable drawable = getDrawable();            if (null == drawable) {                return;            }            // 图片固有宽度            int drawableWidth = drawable.getIntrinsicWidth();            // 图片固有高度            int drawableHeight = drawable.getIntrinsicHeight();            // 接下来对图片做初始的缩放处理，保证图片能看全            if (drawableWidth >= viewWidth && drawableHeight >= viewHeight) {                // 图片宽度和高度都大于控件(缩小)                mBaseScale = Math.min(viewWidth * 1.0f / drawableWidth, viewHeight * 1.0f / drawableHeight);            } else if (drawableWidth > viewWidth && drawableHeight < viewHeight) {                // 图片宽度大于控件,高度小于控件(缩小)                mBaseScale = viewWidth * 1.0f / drawableWidth;            } else if (drawableWidth < viewWidth && drawableHeight > viewHeight) {                // 图片宽度小于控件,高度大于控件(缩小)                mBaseScale = viewHeight * 1.0f / drawableHeight;            } else {                // 图片宽度小于控件,高度小于控件(放大)                mBaseScale = Math.min(viewWidth * 1.0f / drawableWidth, viewHeight * 1.0f / drawableHeight);            }            // 将图片移动到手机屏幕的中间位置            float distanceX = viewWidth / 2 - drawableWidth / 2;            float distanceY = viewHeight / 2 - drawableHeight / 2;            mMatrix.postTranslate(distanceX, distanceY);            mMatrix.postScale(mBaseScale, mBaseScale, viewWidth / 2, viewHeight / 2);            setImageMatrix(mMatrix);        }    }    private float getScale() {        float[] values = new float[9];        mMatrix.getValues(values);        return values[Matrix.MSCALE_X];    }    /**     * 获得图片放大缩小以后的宽和高     */    private RectF getMatrixRectF() {        RectF rectF = new RectF();        Drawable drawable = getDrawable();        if (drawable != null) {            rectF.set(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());            mMatrix.mapRect(rectF);        }        return rectF;    }    /**     * 图片在缩放时进行边界控制     */    private void borderAndCenterCheck() {        RectF rect = getMatrixRectF();        float deltaX = 0;        float deltaY = 0;        int viewWidth = getWidth();        int viewHeight = getHeight();        // 缩放时进行边界检测，防止出现白边        if (rect.width() >= viewWidth) {            if (rect.left > 0) {                deltaX = -rect.left;            }            if (rect.right < viewWidth) {                deltaX = viewWidth - rect.right;            }        }        if (rect.height() >= viewHeight) {            if (rect.top > 0) {                deltaY = -rect.top;            }            if (rect.bottom < viewHeight) {                deltaY = viewHeight - rect.bottom;            }        }        // 如果宽度或者高度小于控件的宽或者高；则让其居中        if (rect.width() < viewWidth) {            deltaX = viewWidth / 2f - rect.right + rect.width() / 2f;        }        if (rect.height() < viewHeight) {            deltaY = viewHeight / 2f - rect.bottom + rect.height() / 2f;        }        mMatrix.postTranslate(deltaX, deltaY);    }}

2.2、ScaleGestureDetector源码分析

ScaleGestureDetector的源码比GestureDetector的源码就要稍微复杂点了，因为ScaleGestureDetector的事件涉及到多个手指。

想要缩放的值，所有的MotionEvent事件都要交给ScaleGestureDetector的onTouchEvent()函数，所以我们就先直接来看下onTouchEvent()函数大概的逻辑。

    public boolean onTouchEvent(MotionEvent event) {        ...        // 缩放的手势是需要多个手指来完成的，count 手指的个数        final int count = event.getPointerCount();        ...        // streamComplete表示当前事件留是否完成        final boolean streamComplete = action == MotionEvent.ACTION_UP ||                                       action == MotionEvent.ACTION_CANCEL || anchoredScaleCancelled;        if (action == MotionEvent.ACTION_DOWN || streamComplete) {            // mInProgress表示是否进行缩放，这里是停掉上一次的缩放调用onScaleEnd()            if (mInProgress) {                mListener.onScaleEnd(this);                mInProgress = false;                mInitialSpan = 0;                mAnchoredScaleMode = ANCHORED_SCALE_MODE_NONE;            } else if (inAnchoredScaleMode() && streamComplete) {                mInProgress = false;                mInitialSpan = 0;                mAnchoredScaleMode = ANCHORED_SCALE_MODE_NONE;            }            if (streamComplete) {                return true;            }        }        ...        if (inAnchoredScaleMode()) {            ...        } else {            // 所有手指的距离相加            for (int i = 0; i < count; i++) {                if (skipIndex == i) continue;                sumX += event.getX(i);                sumY += event.getY(i);            }            // 所有手指的中心点            focusX = sumX / div;            focusY = sumY / div;        }        // Determine average deviation from focal point        float devSumX = 0, devSumY = 0;        for (int i = 0; i < count; i++) {            if (skipIndex == i) continue;            // 所有手指相对于中心点(所有手指的中心点)的距离之和            devSumX += Math.abs(event.getX(i) - focusX);            devSumY += Math.abs(event.getY(i) - focusY);        }        // 所有手指相对于中心点的平均值        final float devX = devSumX / div;        final float devY = devSumY / div;        // *2 相当于是两个手指之间的距离跨度        final float spanX = devX * 2;        final float spanY = devY * 2;        final float span;        if (inAnchoredScaleMode()) {            span = spanY;        } else {            span = (float) Math.hypot(spanX, spanY);        }        ...        final int minSpan = inAnchoredScaleMode() ? mSpanSlop : mMinSpan;        // 回调onScaleBegin()，返回值表示是否开始缩放        if (!mInProgress && span >=  minSpan &&            (wasInProgress || Math.abs(span - mInitialSpan) > mSpanSlop)) {            mPrevSpanX = mCurrSpanX = spanX;            mPrevSpanY = mCurrSpanY = spanY;            mPrevSpan = mCurrSpan = span;            mPrevTime = mCurrTime;            mInProgress = mListener.onScaleBegin(this);        }        // 回调onScale(),如果onScale()返回true,则重新保存mPrevSpanX，mPrevSpanY，mPrevSpan，mPrevTime        if (action == MotionEvent.ACTION_MOVE) {            mCurrSpanX = spanX;            mCurrSpanY = spanY;            mCurrSpan = span;            boolean updatePrev = true;            if (mInProgress) {                updatePrev = mListener.onScale(this);            }            if (updatePrev) {                mPrevSpanX = mCurrSpanX;                mPrevSpanY = mCurrSpanY;                mPrevSpan = mCurrSpan;                mPrevTime = mCurrTime;            }        }        return true;    }

我onTouchEvent()里面的一些关键的地方，直接注释在代码里面了。

onTouchEvent()函数里面，我们要注意onScale()的返回值为true的时候mPrevSpanX，mPrevSpanY，mPrevSpan，mPrevTime这些才会改变。

我再看下缩放过程中的缩放因子是怎么计算到的。getScaleFactor()函数。

    public float getScaleFactor() {        ...        return mPrevSpan > 0 ? mCurrSpan / mPrevSpan : 1;    }

简单吧，用当前两个手指之间的跨度除以上一次记录的两个手指之间的跨度。同时我们也注意到上面讲到的onTouchEvent()函数里面onScale()返回true的时候mPrevSpan才会重新赋值。什么意思，比如我们两个手指放在屏幕上，手指慢慢的拉开。假设回调过程中我们onScale()函数每次返回的是true，每次onScale()之后getScaleFactor()会重新去计算缩放因子，但是如果onScale()函数返回的是false，getScaleFactor()的返回值是一直增大的。

本文中对应的实例下载地址

Android(安卓)GestureDetector ScaleGestureDetector