Android GestureDetector ScaleGestureDetector

客官°小女子只卖身不卖艺 2022-05-21 03:23 220阅读 0赞

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()的返回值是一直增大的。

--------------------

[本文中对应的实例下载地址][Link 1]

[Link 1]: https://github.com/tuacy/GestureDetectorDemo