Android自定义GestureDetector实现手势ImageView

不说废话了，进入我们今天的主题吧。

先贴上前面内容的地址：

Android手势ImageView三部曲（一）

Android手势ImageView三部曲（二）

Android手势ImageView三部曲（三）

前面我们讲到了ScaleGestureDetector这个工具类，我在疑惑，为什么搞出一个ScaleGestureDetector，不顺带把什么旋转、移动、做了呢？ 好吧～！ 谷歌肯定还是想给开发者留一点自己的空间哈。

仿照ScaleGestureDetector，我们来定义一个叫MoveGestureDetector的工具类（专门用于检测滑动手势），在定义MoveGestureDetector之前，因为我们还要考虑到之后的RotateGestureDetector等等..于是我们定一个叫BaseGestureDetector把一些公共的方法抽取出来：

public abstract class BaseGestureDetector {
 protected final Context mContext;
 protected boolean mGestureInProgress;
 protected MotionEvent mPrevEvent;
 protected MotionEvent mCurrEvent;
 protected float mCurrPressure;
 protected float mPrevPressure;
 protected long mTimeDelta;
 
 protected static final float PRESSURE_THRESHOLD = 0.67f;
 public BaseGestureDetector(Context context) {
 mContext = context; 
 }
 
 public boolean onTouchEvent(MotionEvent event){
 //为了获取到ACTION_POINTER_UP等事件必须加上& MotionEvent.ACTION_MASK
 final int actionCode = event.getAction() & MotionEvent.ACTION_MASK;
 
 if (!mGestureInProgress) {
 //如果mGestureInProgress为false的时候，执行开始操作
 handleStartProgressEvent(actionCode, event);
 } else {
 //处理手势
 handleInProgressEvent(actionCode, event);
 }
 return true;
 }
 
 protected abstract void handleStartProgressEvent(int actionCode, MotionEvent event);
 
 protected abstract void handleInProgressEvent(int actionCode, MotionEvent event);
 
 protected void updateStateByEvent(MotionEvent curr){
 final MotionEvent prev = mPrevEvent;
 // Reset mCurrEvent
 if (mCurrEvent != null) {
 mCurrEvent.recycle();
 mCurrEvent = null;
 }
 mCurrEvent = MotionEvent.obtain(curr);
 // 之前的event跟现在的event之间的时间差
 mTimeDelta = curr.getEventTime() - prev.getEventTime();
 // 之前的event跟腺癌的event之间的手指压力值
 mCurrPressure = curr.getPressure(curr.getActionIndex());
 mPrevPressure = prev.getPressure(prev.getActionIndex());
 }
 
 protected void resetState() {
 if (mPrevEvent != null) {
 mPrevEvent.recycle();
 mPrevEvent = null;
 }
 if (mCurrEvent != null) {
 mCurrEvent.recycle();
 mCurrEvent = null;
 }
 mGestureInProgress = false;
 }
 
 public boolean isInProgress() {
 return mGestureInProgress;
 }
 
 public long getTimeDelta() {
 return mTimeDelta;
 }
 
 public long getEventTime() {
 return mCurrEvent.getEventTime();
 }
}

然后我们定义一个叫MoveGestureDetector的类去继承BaseGestureDetector,然后事件两个抽象方法：

public class MoveGestureDetector extends BaseGestureDetector{
 @Override
 protected void handleStartProgressEvent(int actionCode, MotionEvent event){
 ｝
 @Override
 protected void handleInProgressEvent(int actionCode, MotionEvent event){ 
 }
｝

那我们如果检测到了事件的话该怎么通知调用者呢？是的，我们需要用到回调，我们看看ScaleGestureDetector的回调接口咋定义的：

public interface OnScaleGestureListener {
 public boolean onScale(ScaleGestureDetector detector);
 public boolean onScaleBegin(ScaleGestureDetector detector);
 public void onScaleEnd(ScaleGestureDetector detector);
 }
 public static class SimpleOnScaleGestureListener implements OnScaleGestureListener {
 public boolean onScale(ScaleGestureDetector detector) {
 return false;
 }
 public boolean onScaleBegin(ScaleGestureDetector detector) {
 return true;
 }
 public void onScaleEnd(ScaleGestureDetector detector) {
 // Intentionally empty
 }
 }

里面定义了一个接口一个叫OnScaleGestureListener，一个类叫SimpleOnScaleGestureListener，SimpleOnScaleGestureListener是实现了OnScaleGestureListener，于是我们MoveGestureDetector的接口可以这么定义了：

 public interface OnMoveGestureListener {
 
 public boolean onMove(MoveGestureDetector detector);
 
 public boolean onMoveBegin(MoveGestureDetector detector);
 
 public void onMoveEnd(MoveGestureDetector detector);
 }
 public static class SimpleOnMoveGestureListener implements OnMoveGestureListener {
 public boolean onMove(MoveGestureDetector detector) {
 return false;
 }
 public boolean onMoveBegin(MoveGestureDetector detector) {
 return true;
 }
 public void onMoveEnd(MoveGestureDetector detector) {
 // Do nothing, overridden implementation may be used
 }
 }

好啦！框子都搭好了，我们用的时候呢，就可以这么用了：

1、创建一个MoveGestureDetector

 public MatrixImageView(Context context, AttributeSet attrs) {
 super(context, attrs);
 initView();
 //创建一个缩放手势监测器
 scaleDetector=new ScaleGestureDetector(context,onScaleGestureListener);
 //创建一个MoveGestureDetector
 moveGestureDetector=new MoveGestureDetector(context,onMoveGestureListener);
 }

2、把事件给MoveGestureDetector

 @Override
 public boolean onTouchEvent(MotionEvent event) {
 //把事件给scaleDetector
 scaleDetector.onTouchEvent(event);
 //把事件给moveGestureDetector
 moveGestureDetector.onTouchEvent(event);
 return true;
 }

3、获取回调值

private MoveGestureDetector.SimpleOnMoveGestureListener onMoveGestureListener=new MoveGestureDetector.SimpleOnMoveGestureListener(){
 @Override
 public boolean onMove(MoveGestureDetector detector) {
 return super.onMove(detector);
 }
 };

怎么样？是不是跟ScaleGestureDetector一样了呢？清晰明了哈，框子是搭起来了，下面我们来实现下它的逻辑（也就是实现下handleStartProgressEvent跟handleInProgressEvent方法）：

每行都有注释，我就直接上代码了

 */
public class MoveGestureDetector extends BaseGestureDetector {
 
 public interface OnMoveGestureListener {
 
 public boolean onMove(MoveGestureDetector detector);
 
 public boolean onMoveBegin(MoveGestureDetector detector);
 
 public void onMoveEnd(MoveGestureDetector detector);
 }
 public static class SimpleOnMoveGestureListener implements OnMoveGestureListener {
 public boolean onMove(MoveGestureDetector detector) {
 return false;
 }
 public boolean onMoveBegin(MoveGestureDetector detector) {
 return true;
 }
 public void onMoveEnd(MoveGestureDetector detector) {
 // Do nothing, overridden implementation may be used
 }
 }
 private static final PointF FOCUS_DELTA_ZERO = new PointF();
 private final OnMoveGestureListener mListener;
 private PointF mCurrFocusInternal;
 private PointF mPrevFocusInternal; 
 private PointF mFocusExternal = new PointF();
 private PointF mFocusDeltaExternal = new PointF();
 public MoveGestureDetector(Context context, OnMoveGestureListener listener) {
 super(context);
 mListener = listener;
 }
 @Override
 protected void handleStartProgressEvent(int actionCode, MotionEvent event){
 switch (actionCode) {
 //当手指按下的时候
 case MotionEvent.ACTION_DOWN:
 //重置一下所有状态（currevent跟preevent）
 resetState(); // In case we missed an UP/CANCEL event
 //获取当前event作为mPrevEvent
 mPrevEvent = MotionEvent.obtain(event);
 //重置两次event的时间间隔
 mTimeDelta = 0;
 //更新state
 updateStateByEvent(event);
 break;
 case MotionEvent.ACTION_MOVE:
 //回调onMoveBegin，mGestureInProgress决定是否继续处理事件（执行handleInProgressEvent）
 //mGestureInProgress由调用者决定
 mGestureInProgress = mListener.onMoveBegin(this);
 break;
 }
 }
 
 @Override
 protected void handleInProgressEvent(int actionCode, MotionEvent event){ 
 switch (actionCode) {
 //当抬起或者取消的时候
 case MotionEvent.ACTION_UP:
 case MotionEvent.ACTION_CANCEL:
 //回调onMoveEnd，move处理结束
 mListener.onMoveEnd(this);
 //重置所有的state
 resetState();
 break;
 case MotionEvent.ACTION_MOVE:
 //更新状态
 updateStateByEvent(event);
 //当上一次event的press值／这一次event值大于临界值的时候开始触发onMove
 //因为如果CurrPressure / mPrevPressure很小的话，可能手指已经离开屏幕了
 if (mCurrPressure / mPrevPressure > PRESSURE_THRESHOLD) {
 
 final boolean updatePrevious = mListener.onMove(this);
 if (updatePrevious) {
 mPrevEvent.recycle();
 mPrevEvent = MotionEvent.obtain(event);
 }
 }
 break;
 }
 }
 
 protected void updateStateByEvent(MotionEvent curr) {
 super.updateStateByEvent(curr);
 final MotionEvent prev = mPrevEvent;
 // 获取当前所有手指的中心点
 mCurrFocusInternal = determineFocalPoint(curr);
 //获取之前event所有手指的中心点
 mPrevFocusInternal = determineFocalPoint(prev);
 //判断是否有手指中途添加或者移除
 boolean mSkipNextMoveEvent = prev.getPointerCount() != curr.getPointerCount();
 //有移除的话mFocusDeltaExternal就等于空（0，0），没有的话就算出前面event跟当前event中心点距离
 mFocusDeltaExternal = mSkipNextMoveEvent ? FOCUS_DELTA_ZERO : new PointF(mCurrFocusInternal.x - mPrevFocusInternal.x, mCurrFocusInternal.y - mPrevFocusInternal.y);
 //累加距离值
 mFocusExternal.x += mFocusDeltaExternal.x;
 mFocusExternal.y += mFocusDeltaExternal.y; 
 }
 
 private PointF determineFocalPoint(MotionEvent e){
 // Number of fingers on screen
 final int pCount = e.getPointerCount(); 
 float x = 0f;
 float y = 0f;
 for(int i = 0; i < pCount; i++){
 x += e.getX(i);
 y += e.getY(i);
 }
 return new PointF(x/pCount, y/pCount);
 }
 
 public float getFocusX() {
 return mFocusExternal.x;
 }
 public float getFocusY() {
 return mFocusExternal.y;
 }
 
 public PointF getFocusDelta() {
 return mFocusDeltaExternal;
 }
}

好啦！！写完哈，我们来使用一下：

package com.leo.gestureimageview;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.widget.ImageView;
import com.leo.gestureimageview.GestureDetectors.MoveGestureDetector;
public class MatrixImageView extends ImageView {
 private Matrix currMatrix;
 private float scaleFactor=1f;//当前图片的缩放值
 private float transX,transY;
 private ScaleGestureDetector scaleDetector;
 private MoveGestureDetector moveGestureDetector;
 public MatrixImageView(Context context, AttributeSet attrs) {
 super(context, attrs);
 initView();
 //创建一个缩放手势监测器
 scaleDetector=new ScaleGestureDetector(context,onScaleGestureListener);
 //创建一个MoveGestureDetector
 moveGestureDetector=new MoveGestureDetector(context,onMoveGestureListener);
 }
 private void initView() {
 currMatrix = new Matrix();
 DisplayMetrics dm = getResources().getDisplayMetrics();
 Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.test);
 bitmap = Bitmap.createScaledBitmap(bitmap, dm.widthPixels, dm.heightPixels, true);
 setImageBitmap(bitmap);
 }
 @Override
 public boolean onTouchEvent(MotionEvent event) {
 //把事件给scaleDetector
 scaleDetector.onTouchEvent(event);
 //把事件给moveGestureDetector
 moveGestureDetector.onTouchEvent(event);
 return true;
 }
 private void setMatrix(){
 currMatrix.reset();
 currMatrix.postScale(scaleFactor,scaleFactor,getMeasuredWidth()/2,getMeasuredHeight()/2);
 currMatrix.postTranslate(transX,transY);
 setImageMatrix(currMatrix);
 }
 private ScaleGestureDetector.SimpleOnScaleGestureListener onScaleGestureListener=new ScaleGestureDetector.SimpleOnScaleGestureListener(){
 @Override
 public boolean onScale(ScaleGestureDetector detector) {
 scaleFactor *= detector.getScaleFactor(); // scale change since previous event
 // Don't let the object get too small or too large.
 scaleFactor = Math.max(0.1f, Math.min(scaleFactor, 10.0f));
 setMatrix();
 
 return true;
 }
 };
 private MoveGestureDetector.SimpleOnMoveGestureListener onMoveGestureListener=new MoveGestureDetector.SimpleOnMoveGestureListener(){
 @Override
 public boolean onMove(MoveGestureDetector detector) {
 transX=detector.getFocusX();
 transY=detector.getFocusY();
 setMatrix();
 return true;
 }
 };
}

好啦～！！ 短短几行代码就可以玩起来了，效果图我就不附了哈，小伙伴自己运行一下，那么MoveGestureDetector我们实现了，想必RotateGestureDetector也是很快就会实现了，哈哈～～！ 我就直接用贴上国外大神写的代码了：

public class RotateGestureDetector extends TwoFingerGestureDetector {
 
 public interface OnRotateGestureListener {
 public boolean onRotate(RotateGestureDetector detector);
 public boolean onRotateBegin(RotateGestureDetector detector);
 public void onRotateEnd(RotateGestureDetector detector);
 }
 
 public static class SimpleOnRotateGestureListener implements OnRotateGestureListener {
 public boolean onRotate(RotateGestureDetector detector) {
 return false;
 }
 public boolean onRotateBegin(RotateGestureDetector detector) {
 return true;
 }
 public void onRotateEnd(RotateGestureDetector detector) {
 // Do nothing, overridden implementation may be used
 }
 }
 private final OnRotateGestureListener mListener;
 private boolean mSloppyGesture;
 public RotateGestureDetector(Context context, OnRotateGestureListener listener) {
 super(context);
 mListener = listener;
 }
 @Override
 protected void handleStartProgressEvent(int actionCode, MotionEvent event){
 switch (actionCode) {
 case MotionEvent.ACTION_POINTER_DOWN:
 // At least the second finger is on screen now
 resetState(); // In case we missed an UP/CANCEL event
 mPrevEvent = MotionEvent.obtain(event);
 mTimeDelta = 0;
 updateStateByEvent(event);
 // See if we have a sloppy gesture
 mSloppyGesture = isSloppyGesture(event);
 if(!mSloppyGesture){
 // No, start gesture now
 mGestureInProgress = mListener.onRotateBegin(this);
 } 
 break;
 case MotionEvent.ACTION_MOVE:
 if (!mSloppyGesture) {
 break;
 }
 // See if we still have a sloppy gesture
 mSloppyGesture = isSloppyGesture(event);
 if(!mSloppyGesture){
 // No, start normal gesture now
 mGestureInProgress = mListener.onRotateBegin(this);
 }
 break;
 case MotionEvent.ACTION_POINTER_UP:
 if (!mSloppyGesture) {
 break;
 }
 break; 
 }
 }
 @Override
 protected void handleInProgressEvent(int actionCode, MotionEvent event){ 
 switch (actionCode) {
 case MotionEvent.ACTION_POINTER_UP:
 // Gesture ended but 
 updateStateByEvent(event);
 if (!mSloppyGesture) {
 mListener.onRotateEnd(this);
 }
 resetState();
 break;
 case MotionEvent.ACTION_CANCEL:
 if (!mSloppyGesture) {
 mListener.onRotateEnd(this);
 }
 resetState();
 break;
 case MotionEvent.ACTION_MOVE:
 updateStateByEvent(event);
 // Only accept the event if our relative pressure is within
 // a certain limit. This can help filter shaky data as a
 // finger is lifted.
 if (mCurrPressure / mPrevPressure > PRESSURE_THRESHOLD) {
 final boolean updatePrevious = mListener.onRotate(this);
 if (updatePrevious) {
 mPrevEvent.recycle();
 mPrevEvent = MotionEvent.obtain(event);
 }
 }
 break;
 }
 }
 @Override
 protected void resetState() {
 super.resetState();
 mSloppyGesture = false;
 }
 
 public float getRotationDegreesDelta() {
 double diffRadians = Math.atan2(mPrevFingerDiffY, mPrevFingerDiffX) - Math.atan2(mCurrFingerDiffY, mCurrFingerDiffX);
 return (float) (diffRadians * 180 / Math.PI);
 }
}

最后把我们结合了ScaleDetector、MoveDetector、RotateDetector的一个手势缩放ImageView的代码给大家：

package com.leo.gestureimageview;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.widget.ImageView;
import com.leo.gestureimageview.GestureDetectors.MoveGestureDetector;
import com.leo.gestureimageview.GestureDetectors.RotateGestureDetector;
public class MatrixImageView2 extends ImageView {
 private Matrix mMatrix = new Matrix();
 private float mScaleFactor =1f;
 private float mRotationDegrees = 0.f;
 private float mFocusX = 0.f;
 private float mFocusY = 0.f;
 private ScaleGestureDetector mScaleDetector;
 private RotateGestureDetector mRotateDetector;
 private MoveGestureDetector mMoveDetector;
 public MatrixImageView2(Context context, AttributeSet attrs) {
 super(context, attrs);
 initView();
 }
 private void initView() {
 //初始化模式为初始状态
 DisplayMetrics dm = getResources().getDisplayMetrics();
 //给ImageView设置一张图片（此处为了测试直接在imageview里面设置了一张测试图片）
 Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.test);
 bitmap = Bitmap.createScaledBitmap(bitmap, dm.widthPixels, dm.heightPixels, true);
 setImageBitmap(bitmap);
 mScaleDetector = new ScaleGestureDetector(getContext(), new ScaleListener());
 mRotateDetector = new RotateGestureDetector(getContext(), new RotateListener());
 mMoveDetector = new MoveGestureDetector(getContext(), new MoveListener());
 mFocusX = dm.widthPixels/2f;
 mFocusY = dm.heightPixels/2f;
 }
 @Override
 public boolean onTouchEvent(MotionEvent event) {
 //把缩放事件给mScaleDetector
 mScaleDetector.onTouchEvent(event);
 //把旋转事件个mRotateDetector
 mRotateDetector.onTouchEvent(event);
 //把移动事件给mMoveDetector
 mMoveDetector.onTouchEvent(event);
 return true;
 }
 private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
 @Override
 public boolean onScale(ScaleGestureDetector detector) {
 mScaleFactor *= detector.getScaleFactor(); // scale change since previous event
 // Don't let the object get too small or too large.
 mScaleFactor = Math.max(0.1f, Math.min(mScaleFactor, 10.0f));
 changeMatrix();
 return true;
 }
 }
 private class RotateListener extends RotateGestureDetector.SimpleOnRotateGestureListener {
 @Override
 public boolean onRotate(RotateGestureDetector detector) {
 mRotationDegrees -= detector.getRotationDegreesDelta();
 changeMatrix();
 return true;
 }
 }
 private class MoveListener extends MoveGestureDetector.SimpleOnMoveGestureListener {
 @Override
 public boolean onMove(MoveGestureDetector detector) {
 PointF d = detector.getFocusDelta();
 mFocusX += d.x;
 mFocusY += d.y;
 changeMatrix();
 return true;
 }
 }
 private void changeMatrix(){
 float scaledImageCenterX = (getDrawable().getIntrinsicWidth()*mScaleFactor)/2;
 float scaledImageCenterY = (getDrawable().getIntrinsicHeight()*mScaleFactor)/2;
 mMatrix.reset();
 mMatrix.postScale(mScaleFactor, mScaleFactor);
 mMatrix.postRotate(mRotationDegrees, scaledImageCenterX, scaledImageCenterY);
 mMatrix.postTranslate(mFocusX - scaledImageCenterX, mFocusY - scaledImageCenterY);
 setImageMatrix(mMatrix);
 }
}

好啦～～～小伙伴也可以自己下载一下这个框架的代码去研究，我这呢也只是把自己学习的心得分享给大家。
https://github.com/Almeros/android-gesture-detectors

嗯嗯！说了那么多，最后让我们看看传说中的PhotoView到底是咋实现的。

photoview的github链接：
https://github.com/chrisbanes/PhotoViewary/

看完我们之前的内容，再去看PhotoView的话，你可能不会那么迷茫了，下面让我们一起揭开它的神秘面纱：

首先PhotoView的用法呢，很简单，小伙伴像用ImageView一样用它就可以了：

<uk.co.senab.photoview.PhotoView
 android:clickable="true"
 android:layout_width="match_parent"
 android:layout_height="match_parent"
 android:scaleType="fitxy"
 />

好啦！！现在就可以对图片进行缩放、旋转、移动操作啦～是不是很爽呢？

但是注意：

photoview的缩放类型不支持，不然就直接报错退出了：

android:scaleType="matrix"

我们来看看它的源码：

public class PhotoView extends ImageView implements IPhotoView {
 private PhotoViewAttacher mAttacher;
 private ScaleType mPendingScaleType;
 public PhotoView(Context context) {
 this(context, null);
 }
 public PhotoView(Context context, AttributeSet attr) {
 this(context, attr, 0);
 }
 public PhotoView(Context context, AttributeSet attr, int defStyle) {
 super(context, attr, defStyle);
 super.setScaleType(ScaleType.MATRIX);
 init();
 }
 protected void init() {
 if (null == mAttacher || null == mAttacher.getImageView()) {
 mAttacher = new PhotoViewAttacher(this);
 }
 if (null != mPendingScaleType) {
 setScaleType(mPendingScaleType);
 mPendingScaleType = null;
 }
 }
 @Override
 public void setRotationTo(float rotationDegree) {
 mAttacher.setRotationTo(rotationDegree);
 }
 @Override
 public void setRotationBy(float rotationDegree) {
 mAttacher.setRotationBy(rotationDegree);
 }
 @Override
 public boolean canZoom() {
 return mAttacher.canZoom();
 }
 @Override
 public RectF getDisplayRect() {
 return mAttacher.getDisplayRect();
 }
 @Override
 public void getDisplayMatrix(Matrix matrix) {
 mAttacher.getDisplayMatrix(matrix);
 }
 @Override
 public boolean setDisplayMatrix(Matrix finalRectangle) {
 return mAttacher.setDisplayMatrix(finalRectangle);
 }
 @Override
 public float getMinimumScale() {
 return mAttacher.getMinimumScale();
 }
 @Override
 public float getMediumScale() {
 return mAttacher.getMediumScale();
 }
 @Override
 public float getMaximumScale() {
 return mAttacher.getMaximumScale();
 }
 @Override
 public float getScale() {
 return mAttacher.getScale();
 }
 @Override
 public ScaleType getScaleType() {
 return mAttacher.getScaleType();
 }
 @Override
 public Matrix getImageMatrix() {
 return mAttacher.getImageMatrix();
 }
 @Override
 public void setAllowParentInterceptOnEdge(boolean allow) {
 mAttacher.setAllowParentInterceptOnEdge(allow);
 }
 @Override
 public void setMinimumScale(float minimumScale) {
 mAttacher.setMinimumScale(minimumScale);
 }
 @Override
 public void setMediumScale(float mediumScale) {
 mAttacher.setMediumScale(mediumScale);
 }
 @Override
 public void setMaximumScale(float maximumScale) {
 mAttacher.setMaximumScale(maximumScale);
 }
 @Override
 public void setScaleLevels(float minimumScale, float mediumScale, float maximumScale) {
 mAttacher.setScaleLevels(minimumScale, mediumScale, maximumScale);
 }
 @Override
 // setImageBitmap calls through to this method
 public void setImageDrawable(Drawable drawable) {
 super.setImageDrawable(drawable);
 if (null != mAttacher) {
 mAttacher.update();
 }
 }
 @Override
 public void setImageResource(int resId) {
 super.setImageResource(resId);
 if (null != mAttacher) {
 mAttacher.update();
 }
 }
 @Override
 public void setImageURI(Uri uri) {
 super.setImageURI(uri);
 if (null != mAttacher) {
 mAttacher.update();
 }
 }
 @Override
 protected boolean setFrame(int l, int t, int r, int b) {
 boolean changed = super.setFrame(l, t, r, b);
 if (null != mAttacher) {
 mAttacher.update();
 }
 return changed;
 }
 @Override
 public void setOnMatrixChangeListener(OnMatrixChangedListener listener) {
 mAttacher.setOnMatrixChangeListener(listener);
 }
 @Override
 public void setOnLongClickListener(OnLongClickListener l) {
 mAttacher.setOnLongClickListener(l);
 }
 @Override
 public void setOnPhotoTapListener(OnPhotoTapListener listener) {
 mAttacher.setOnPhotoTapListener(listener);
 }
 @Override
 public void setOnViewTapListener(OnViewTapListener listener) {
 mAttacher.setOnViewTapListener(listener);
 }
 @Override
 public void setScale(float scale) {
 mAttacher.setScale(scale);
 }
 @Override
 public void setScale(float scale, boolean animate) {
 mAttacher.setScale(scale, animate);
 }
 @Override
 public void setScale(float scale, float focalX, float focalY, boolean animate) {
 mAttacher.setScale(scale, focalX, focalY, animate);
 }
 @Override
 public void setScaleType(ScaleType scaleType) {
 if (null != mAttacher) {
 mAttacher.setScaleType(scaleType);
 } else {
 mPendingScaleType = scaleType;
 }
 }
 @Override
 public void setZoomable(boolean zoomable) {
 mAttacher.setZoomable(zoomable);
 }
 @Override
 public Bitmap getVisibleRectangleBitmap() {
 return mAttacher.getVisibleRectangleBitmap();
 }
 @Override
 public void setZoomTransitionDuration(int milliseconds) {
 mAttacher.setZoomTransitionDuration(milliseconds);
 }
 @Override
 public IPhotoView getIPhotoViewImplementation() {
 return mAttacher;
 }
 @Override
 public void setOnDoubleTapListener(GestureDetector.OnDoubleTapListener newOnDoubleTapListener) {
 mAttacher.setOnDoubleTapListener(newOnDoubleTapListener);
 }
 @Override
 public void setOnScaleChangeListener(PhotoViewAttacher.OnScaleChangeListener onScaleChangeListener) {
 mAttacher.setOnScaleChangeListener(onScaleChangeListener);
 }
 @Override
 public void setOnSingleFlingListener(PhotoViewAttacher.OnSingleFlingListener onSingleFlingListener) {
 mAttacher.setOnSingleFlingListener(onSingleFlingListener);
 }
 @Override
 protected void onDetachedFromWindow() {
 mAttacher.cleanup();
 mAttacher = null;
 super.onDetachedFromWindow();
 }
 @Override
 protected void onAttachedToWindow() {
 init();
 super.onAttachedToWindow();
 }
}

可以看到，代码并不多，才200多行（哈哈！！我们自己实现的MatrixImageView 100行都还不到呢！！开玩笑哈,PhotoView里面考虑的东西跟兼容性，我们写的MatrixImageView远远不及哈），主要的处理所及都在PhotoViewAttacher这个类中：

PhotoViewAttacher.java:

代码太多，我们看看它的构造方法

 public PhotoViewAttacher(ImageView imageView, boolean zoomable) {
 mImageView = new WeakReference<>(imageView);
 imageView.setDrawingCacheEnabled(true);
 imageView.setOnTouchListener(this);
 ViewTreeObserver observer = imageView.getViewTreeObserver();
 if (null != observer)
 observer.addOnGlobalLayoutListener(this);
 // Make sure we using MATRIX Scale Type
 setImageViewScaleTypeMatrix(imageView);
 if (imageView.isInEditMode()) {
 return;
 }
 // Create Gesture Detectors...
 mScaleDragDetector = VersionedGestureDetector.newInstance(
 imageView.getContext(), this);
 mGestureDetector = new GestureDetector(imageView.getContext(),
 new GestureDetector.SimpleOnGestureListener() {
 // forward long click listener
 @Override
 public void onLongPress(MotionEvent e) {
 if (null != mLongClickListener) {
 mLongClickListener.onLongClick(getImageView());
 }
 }
 @Override
 public boolean onFling(MotionEvent e1, MotionEvent e2,
  float velocityX, float velocityY) {
 if (mSingleFlingListener != null) {
 if (getScale() > DEFAULT_MIN_SCALE) {
 return false;
 }
 if (MotionEventCompat.getPointerCount(e1) > SINGLE_TOUCH
  || MotionEventCompat.getPointerCount(e2) > SINGLE_TOUCH) {
 return false;
 }
 return mSingleFlingListener.onFling(e1, e2, velocityX, velocityY);
 }
 return false;
 }
 });
 mGestureDetector.setOnDoubleTapListener(new DefaultOnDoubleTapListener(this));
 mBaseRotation = 0.0f;
 // Finally, update the UI so that we're zoomable
 setZoomable(zoomable);
 }

可以看到，它也是创建了一个mScaleDragDetector跟一个mGestureDetector用于监听手势变幻，那么事件处理在什么地方呢？

我们在构造方法还发现了一行代码，给当前imageView设置触碰监听：

imageView.setOnTouchListener(this);

小伙伴猜都猜到了，现在就是把事件给事件监听器了：

@Override
 public boolean onTouch(View v, MotionEvent ev) {
 boolean handled = false;
 if (mZoomEnabled && hasDrawable((ImageView) v)) {
 ViewParent parent = v.getParent();
 switch (ev.getAction()) {
 case ACTION_DOWN:
 // First, disable the Parent from intercepting the touch
 // event
 if (null != parent) {
 parent.requestDisallowInterceptTouchEvent(true);
 } else {
 LogManager.getLogger().i(LOG_TAG, "onTouch getParent() returned null");
 }
 // If we're flinging, and the user presses down, cancel
 // fling
 cancelFling();
 break;
 case ACTION_CANCEL:
 case ACTION_UP:
 // If the user has zoomed less than min scale, zoom back
 // to min scale
 if (getScale() < mMinScale) {
 RectF rect = getDisplayRect();
 if (null != rect) {
 v.post(new AnimatedZoomRunnable(getScale(), mMinScale,
  rect.centerX(), rect.centerY()));
 handled = true;
 }
 }
 break;
 }
 // Try the Scale/Drag detector
 if (null != mScaleDragDetector) {
 boolean wasScaling = mScaleDragDetector.isScaling();
 boolean wasDragging = mScaleDragDetector.isDragging();
 handled = mScaleDragDetector.onTouchEvent(ev);
 boolean didntScale = !wasScaling && !mScaleDragDetector.isScaling();
 boolean didntDrag = !wasDragging && !mScaleDragDetector.isDragging();
 mBlockParentIntercept = didntScale && didntDrag;
 }
 // Check to see if the user double tapped
 if (null != mGestureDetector && mGestureDetector.onTouchEvent(ev)) {
 handled = true;
 }
 }
 return handled;
 }

最后处理完毕事件后，就是一系列的回调了，回调完毕后就应该给ImageView重新设置matrix对象了，比如缩放：

@Override
 public void setScale(float scale, float focalX, float focalY,
 boolean animate) {
 ImageView imageView = getImageView();
 if (null != imageView) {
 // Check to see if the scale is within bounds
 if (scale < mMinScale || scale > mMaxScale) {
 LogManager
 .getLogger()
 .i(LOG_TAG,
 "Scale must be within the range of minScale and maxScale");
 return;
 }
 if (animate) {
 imageView.post(new AnimatedZoomRunnable(getScale(), scale,
 focalX, focalY));
 } else {
 mSuppMatrix.setScale(scale, scale, focalX, focalY);
 checkAndDisplayMatrix();
 }
 }
 }

其它的类似哈～～～ 代码还是挺多的（考虑的情况比较多）可想而之，要写好一个自定义组件还不是那么简单的事哦，不过还是加油吧～！

您可能感兴趣的文章:Android编程使用GestureDetector实现简单手势监听与处理的方法Android手势识别器GestureDetector使用详解Android GestureDetector用户手势检测实例讲解Android自定义viewgroup可滚动布局 GestureDetector手势监听（5）Android GestureDetector手势滑动使用实例讲解Android触摸及手势操作GestureDetectorandroid使用gesturedetector手势识别示例分享Android GestureDetector实现手势滑动效果