Android 開源專案PhotoView原始碼分析

https://github.com/chrisbanes/PhotoView/tree/master/library

這個就是專案地址，相信很多人都用過，我依然不去講怎麼使用。只講他的原理和具體實現。

具體會講到：

1.如何實現pinch手勢 放大縮小圖片。

2.如何實現的拖動圖片。

3.如何實現的慣性拖動。

4.如何控制與父view的 事件監聽

主要就是這三點。

具體的呼叫方法 主要是下面這樣：

  ImageView mImageView = (ImageView) findViewById(R.id.iv_photo);
        mCurrMatrixTv = (TextView) findViewById(R.id.tv_current_matrix);

        Drawable bitmap = getResources().getDrawable(R.drawable.wallpaper);
        mImageView.setImageDrawable(bitmap);

        //將imageview和PhotoViewAttacher 這個控制器關聯起來
        mAttacher = new PhotoViewAttacher(mImageView);

可以看出來 主要的工作都是在這個PhotoViewAttacher裡做的。

我們來跟著他的建構函式 看

 //預設建構函式是可以被放大縮小的 zoomable 為true
    public PhotoViewAttacher(ImageView imageView) {
        this(imageView, true);
    }

    public PhotoViewAttacher(ImageView imageView, boolean zoomable) {
        //這個是防止記憶體洩露的一個技巧，注意你在activity裡的imageview 物件如果把引用傳進來的話
        //那這裡的mImageView 也是指向外層的ImageView那個物件，那麼就相當於有2個引用指向同一塊地址！
        //當你外層的imageview物件被銷燬的時候，因為這裡還有一個引用指向那個物件，所以實際上物件不會被銷燬
        //只是最外層的那個imageview物件的引用成了null而已，但是如果你在這裡用了弱引用的話，當外層的強引用
        //為NUll的話 imageview物件會立刻被銷燬掉。
        mImageView = new WeakReference<>(imageView);

        //這個draswingcache 我們做截圖的時候會經常用到，只需要理解成我們可以通過getDrawingCache拿到view裡的內容（這個內容被轉成了bitmap）
        imageView.setDrawingCacheEnabled(true);
        imageView.setOnTouchListener(this);

        //這裡就是監聽imageview的 layout變化用的 imageview發生變化就會呼叫這個回撥介面
        ViewTreeObserver observer = imageView.getViewTreeObserver();
        if (null != observer)
            observer.addOnGlobalLayoutListener(this);

        // 設定繪製時這個imageview 可以隨著matrix矩陣進行變換
        setImageViewScaleTypeMatrix(imageView);
        //這個是讓你在視覺化介面能看到預覽效果的，大家自定義控制元件時 也可以使用這個技巧
        if (imageView.isInEditMode()) {
            return ;
        }
        // Create Gesture Detectors...
        //根據版本不同 取得需要的mScaleDragDetector 主要就是監聽pinch手勢的
        mScaleDragDetector = VersionedGestureDetector.newInstance(
                imageView.getContext(), this);

        //這個dectecor 就是用來監聽雙擊和長按事件的  
        mGestureDetector = new GestureDetector(imageView.getContext(),
                new GestureDetector.SimpleOnGestureListener() {

                    // forward long click listener
                    @Override
                    public void onLongPress(MotionEvent e) {
                        if (null != mLongClickListener) {
                            mLongClickListener.onLongClick(getImageView());
                        }
                    }
                });
        //監聽雙擊手勢的
        mGestureDetector.setOnDoubleTapListener(new DefaultOnDoubleTapListener(this));

        // Finally, update the UI so that we're zoomable
        setZoomable(zoomable);

我們先看19-21行 這個裡面加了一個監聽layout變化的一個回撥，我們來看看這個回撥做了什麼：

 @Override
    public void onGlobalLayout() {
        ImageView imageView = getImageView();

        if (null != imageView) {
            if (mZoomEnabled) {
                //這個地方要注意imageview的 四個座標點是永遠不會變化的。
                final int top = imageView.getTop();
                final int right = imageView.getRight();
                final int bottom = imageView.getBottom();
                final int left = imageView.getLeft();

                /**
                 * We need to check whether the ImageView's bounds have changed.
                 * This would be easier if we targeted API 11+ as we could just use
                 * View.OnLayoutChangeListener. Instead we have to replicate the
                 * work, keeping track of the ImageView's bounds and then checking
                 * if the values change.
                 */
                if (top != mIvTop || bottom != mIvBottom || left != mIvLeft
                        || right != mIvRight) {
                    // Update our base matrix, as the bounds have changed
                    updateBaseMatrix(imageView.getDrawable());

                    // Update values as something has changed
                    mIvTop = top;
                    mIvRight = right;
                    mIvBottom = bottom;
                    mIvLeft = left;
                }
            } else {
                updateBaseMatrix(imageView.getDrawable());
            }
        }
    }

然後跟進去發現是這個函式：

/**
     * Calculate Matrix for FIT_CENTER
     *
     * @param d - Drawable being displayed
     */
    private void updateBaseMatrix(Drawable d) {
        ImageView imageView = getImageView();
        if (null == imageView || null == d) {
            return;
        }

        final float viewWidth = getImageViewWidth(imageView);
        final float viewHeight = getImageViewHeight(imageView);
        //這個是取原始圖片大小的 永遠不會變化的
        final int drawableWidth = d.getIntrinsicWidth();
        final int drawableHeight = d.getIntrinsicHeight();

        mBaseMatrix.reset();

        final float widthScale = viewWidth / drawableWidth;
        final float heightScale = viewHeight / drawableHeight;

        //根據傳進去的scaletype的值來確定 基礎的matrix大小
        if (mScaleType == ScaleType.CENTER) {
            mBaseMatrix.postTranslate((viewWidth - drawableWidth) / 2F,
                    (viewHeight - drawableHeight) / 2F);

        } else if (mScaleType == ScaleType.CENTER_CROP) {
            float scale = Math.max(widthScale, heightScale);
            mBaseMatrix.postScale(scale, scale);
            mBaseMatrix.postTranslate((viewWidth - drawableWidth * scale) / 2F,
                    (viewHeight - drawableHeight * scale) / 2F);

        } else if (mScaleType == ScaleType.CENTER_INSIDE) {
            float scale = Math.min(1.0f, Math.min(widthScale, heightScale));
            mBaseMatrix.postScale(scale, scale);
            mBaseMatrix.postTranslate((viewWidth - drawableWidth * scale) / 2F,
                    (viewHeight - drawableHeight * scale) / 2F);

        } else {
            RectF mTempSrc = new RectF(0, 0, drawableWidth, drawableHeight);
            RectF mTempDst = new RectF(0, 0, viewWidth, viewHeight);

            switch (mScaleType) {
                case FIT_CENTER:
                    mBaseMatrix
                            .setRectToRect(mTempSrc, mTempDst, ScaleToFit.CENTER);
                    break;

                case FIT_START:
                    mBaseMatrix.setRectToRect(mTempSrc, mTempDst, ScaleToFit.START);
                    break;

                case FIT_END:
                    mBaseMatrix.setRectToRect(mTempSrc, mTempDst, ScaleToFit.END);
                    break;

                case FIT_XY:
                    mBaseMatrix.setRectToRect(mTempSrc, mTempDst, ScaleToFit.FILL);
                    break;

                default:
                    break;
            }
        }

        resetMatrix();
    }

其實這邊程式碼很容易懂，大家都知道 imageview裡面是一個圖片對吧，你這個圖片有大有小，那你是怎麼放置在imageview裡面就有講究了，你在imageview裡是可以設定的他的scaletype的屬性的，

那當然了你設定完畢以後 肯定相對於原圖片來說 你已經做了一次matrix變換了，所以你要記錄這次matrix的值。這裡你只要記住對於一個imageview 來說 他本身容器的大小是固定的，

容器裡面的drawable的原圖大小也是固定的，但是現實效果是通過matrix來控制的，所以我們要記錄每一次圖片發生變化的時候matrix的值，這是很關鍵的。

然後回到我們的建構函式看31-32行。這裡構造了一個

uk.co.senab.photoview.gestures.GestureDetector mScaleDragDetector

我們也繼續看看這個是如何構造出來的

public final class VersionedGestureDetector {

    public static GestureDetector newInstance(Context context,
                                              OnGestureListener listener) {
        final int sdkVersion = Build.VERSION.SDK_INT;
        GestureDetector detector;
        if (sdkVersion < Build.VERSION_CODES.ECLAIR) {
            detector = new CupcakeGestureDetector(context);
        } else if (sdkVersion < Build.VERSION_CODES.FROYO) {
            detector = new EclairGestureDetector(context);
        } else {
            //現在大部分 都是呼叫的這個
            detector = new FroyoGestureDetector(context);
        }

        detector.setOnGestureListener(listener);

        return detector;
    }

}

我們發現這個地方是一個單例，實際上這邊程式碼就是根據sdk的版本號不同 提供不一樣的功能，比如說pinch手勢 在4.0以下就沒有支援 那當然了，我們現在百分之95以上的機器都是4.0以上的，

我們只要分析12-13行就可以。

 

/*******************************************************************************
 * Copyright 2011, 2012 Chris Banes.
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
package uk.co.senab.photoview.gestures;

import android.annotation.TargetApi;
import android.content.Context;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;

@TargetApi(8)
//能看出來 低於這個版本的 都不支援pinch 放大縮小功能
public class FroyoGestureDetector extends EclairGestureDetector {

    //用於檢測縮放的手勢
    protected final ScaleGestureDetector mDetector;

    public FroyoGestureDetector(Context context) {
        super(context);

        ScaleGestureDetector.OnScaleGestureListener mScaleListener = new ScaleGestureDetector.OnScaleGestureListener() {

            @Override
            public boolean onScale(ScaleGestureDetector detector) {
                float scaleFactor = detector.getScaleFactor();

                if (Float.isNaN(scaleFactor) || Float.isInfinite(scaleFactor))
                    return false;

                mListener.onScale(scaleFactor,
                        detector.getFocusX(), detector.getFocusY());
                return true;
            }

            //這個函式返回true的時候 onScale函式才會真正呼叫
            @Override
            public boolean onScaleBegin(ScaleGestureDetector detector) {
                return true;
            }

            @Override
            public void onScaleEnd(ScaleGestureDetector detector) {
                // NO-OP
            }
        };
        mDetector = new ScaleGestureDetector(context, mScaleListener);
    }

    @Override
    public boolean isScaling() {
        return mDetector.isInProgress();
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        mDetector.onTouchEvent(ev);
        return super.onTouchEvent(ev);
    }

}

33行-58行 才是真正系統提供給我們的監聽pinch手勢的地方。就是我們印象中 兩指放大縮小圖片的那個手勢的監聽。看42-43行

這裡發現使用了一個回撥，回過頭去看我們的建構函式 我們就知道這個回撥 實際上就是在控制器裡他自己實現的。

public class PhotoViewAttacher implements IPhotoView, View.OnTouchListener,
        OnGestureListener,
        ViewTreeObserver.OnGlobalLayoutListener {

所以我們就到控制器裡去找這個手勢監聽的實現程式碼：

//這個就是處理pinch 手勢的，放大 縮小圖片的處理函式
    @Override
    public void onScale(float scaleFactor, float focusX, float focusY) {
        if (DEBUG) {
            LogManager.getLogger().d(
                    LOG_TAG,
                    String.format("onScale: scale: %.2f. fX: %.2f. fY: %.2f",
                            scaleFactor, focusX, focusY));
        }
        if (getScale() < mMaxScale || scaleFactor < 1f) {
            //這個回撥介面 你可以不用set的，通常來說 我們很少實現這個介面，有需要的可以自己去看註釋這介面的意思
            if (null != mScaleChangeListener) {
                mScaleChangeListener.onScaleChange(scaleFactor, focusX, focusY);
            }
            //這個地方要注意 這個放大 並不是固定的以圖片中心放大的。他是以你兩個手指做pinch手勢的
            //的時候 取點來放大的，這麼做的一個好的地方是 你可以放大圖片中某一部分，而不是隻能從
            //從圖片中間部分開始放大縮小。但是你可以想一下，這麼做的弊端就是 很容易因為你的放大縮小
            //因為點不在中間，所以圖片很有可能就不在imageview這個控制元件的中間，會讓imageview邊緣或者其他地方
            //有留白
            mSuppMatrix.postScale(scaleFactor, scaleFactor, focusX, focusY);
            //而這個函式就是解決上述弊端的，
            checkAndDisplayMatrix();
        }
    }

 /**
     * Helper method that simply checks the Matrix, and then displays the result
     */
    private void checkAndDisplayMatrix() {
        //實際上在matrix裡就解決了上述的弊端
        if (checkMatrixBounds()) {
            setImageViewMatrix(getDrawMatrix());
        }
    }

 //檢查當前顯示範圍是否在邊界上  然後對圖片進行平移（垂直或水平方向） 防止出現留白的現象
    private boolean checkMatrixBounds() {
        final ImageView imageView = getImageView();
        if (null == imageView) {
            return false;
        }

        final RectF rect = getDisplayRect(getDrawMatrix());
        if (null == rect) {
            return false;
        }

        final float height = rect.height(), width = rect.width();
        float deltaX = 0, deltaY = 0;

        final int viewHeight = getImageViewHeight(imageView);
        if (height <= viewHeight) {
            switch (mScaleType) {
                case FIT_START:
                    deltaY = -rect.top;
                    break;
                case FIT_END:
                    deltaY = viewHeight - height - rect.top;
                    break;
                default:
                    deltaY = (viewHeight - height) / 2 - rect.top;
                    break;
            }
        } else if (rect.top > 0) {
            deltaY = -rect.top;
        } else if (rect.bottom < viewHeight) {
            deltaY = viewHeight - rect.bottom;
        }

        final int viewWidth = getImageViewWidth(imageView);
        if (width <= viewWidth) {
            switch (mScaleType) {
                case FIT_START:
                    deltaX = -rect.left;
                    break;
                case FIT_END:
                    deltaX = viewWidth - width - rect.left;
                    break;
                default:
                    deltaX = (viewWidth - width) / 2 - rect.left;
                    break;
            }
            mScrollEdge = EDGE_BOTH;
        } else if (rect.left > 0) {
            mScrollEdge = EDGE_LEFT;
            deltaX = -rect.left;
        } else if (rect.right < viewWidth) {
            deltaX = viewWidth - rect.right;
            mScrollEdge = EDGE_RIGHT;
        } else {
            mScrollEdge = EDGE_NONE;
        }

        // Finally actually translate the matrix
        mSuppMatrix.postTranslate(deltaX, deltaY);
        return true;
    }

這個地方有的人可能會對最後那個檢測是否在邊界的那個函式不太明白，其實還是挺好理解的，對於容器imageview來說 他的範圍是固定的。裡面的drawable是不斷的變化的，

但是這個drawable 可以和 RectF來關聯起來，這個rectF 就是描述出一個矩形，這個矩形就恰好是drawable的大小範圍。他有四個值 分別是top left right和bottom。

其中2個值表示矩形的左上面ed點的座標 另外2個表示右下角的座標。一個矩形由這2個點即可確定位置以及大小。我用下圖來表示：

 

所以那個函式你要想理解的話 就是自己去畫個圖。就能知道如何判斷是否到邊緣了！實際上就是drawbl---matrix---rectF的一個轉換。
另外一定要自己畫圖 才能真正理解 裡面的邏輯 很簡單 並不難！

那這個onscale 手勢我們過了一遍以後 看看這個函式是怎麼被呼叫的
很簡單 還是通過onTouch事件

 @SuppressLint("ClickableViewAccessibility")
    @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) {
                        //阻止父層的View截獲touch事件
                        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:
                    //放大縮小都得有一個度，這個地方就是說 如果你縮的太小了，比如我們定義的是縮小到原圖的百分之25
                    //如果你縮小到百分之10了，那麼當你手指鬆開的時候 就要自動將圖片還原到百分之25，當然這個過程
                    //你得使用動畫慢慢從10回覆到25，因為一下子回覆到25 實在是太難看了
                    //在下一幀繪製前,系統會執行該 Runnable,這樣我們就可以在 runnable 中更新 UI 狀態.
                    //原理上類似一個遞迴呼叫,每次 UI 繪製前更新 UI 狀態,並指定下次 UI 更新前再執行自己.
                    //這種寫法 與 使用迴圈或 Handler 每隔 16ms 重新整理一次 UI 基本等價,但是更為方便快捷
                    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();
                //這行程式碼是最終交給pinch手勢監聽的程式碼
                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;
    }

好 到這個地方 相信大家對 pinch事件就理解的差不多了 包括是怎麼被呼叫的這個過程 以及中間的缺陷處理 都明白了。我們繼續看drag 也就是拖動是怎麼處理的。

/能看出來 低於這個版本的 都不支援pinch 放大縮小功能
public class FroyoGestureDetector extends EclairGestureDetector {

看的到 他是繼承自這個類的

@TargetApi(5)
public class EclairGestureDetector extends CupcakeGestureDetector {

/*******************************************************************************
 * Copyright 2011, 2012 Chris Banes.
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
package uk.co.senab.photoview.gestures;

import android.content.Context;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.ViewConfiguration;

import uk.co.senab.photoview.log.LogManager;

public class CupcakeGestureDetector implements GestureDetector {

    //慣性滑動拖動處理
    protected OnGestureListener mListener;
    private static final String LOG_TAG = "CupcakeGestureDetector";
    float mLastTouchX;
    float mLastTouchY;
    final float mTouchSlop;
    final float mMinimumVelocity;

    @Override
    public void setOnGestureListener(OnGestureListener listener) {
        this.mListener = listener;
    }

    public CupcakeGestureDetector(Context context) {
        final ViewConfiguration configuration = ViewConfiguration
                .get(context);
        mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
        mTouchSlop = configuration.getScaledTouchSlop();
    }

    private VelocityTracker mVelocityTracker;
    private boolean mIsDragging;

    float getActiveX(MotionEvent ev) {
        return ev.getX();
    }

    float getActiveY(MotionEvent ev) {
        return ev.getY();
    }

    public boolean isScaling() {
        return false;
    }

    public boolean isDragging() {
        return mIsDragging;
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN: {
                mVelocityTracker = VelocityTracker.obtain();
                if (null != mVelocityTracker) {
                    mVelocityTracker.addMovement(ev);
                } else {
                    LogManager.getLogger().i(LOG_TAG, "Velocity tracker is null");
                }

                mLastTouchX = getActiveX(ev);
                mLastTouchY = getActiveY(ev);
                mIsDragging = false;
                break;
            }

            case MotionEvent.ACTION_MOVE: {
                //這個拖動事件其實也很好理解，就是確定你的手指在滑動的時候座標點的變化
                //這個變化要理解好 就是你可以把螢幕左上角的點 想象成一個座標系的原點。
                //那你如果要計算某個座標點和這個原點的直線距離 實際上就是 這個座標點的
                // x*x+y*y 然後把這個值開根號即可，初中數學問題！只要你每次這個直線距離
                //有變化 那就肯定是拖動事件了
                final float x = getActiveX(ev);
                final float y = getActiveY(ev);
                final float dx = x - mLastTouchX, dy = y - mLastTouchY;

                if (!mIsDragging) {
                    // Use Pythagoras to see if drag length is larger than
                    // touch slop
                    mIsDragging = Math.sqrt((dx * dx) + (dy * dy)) >= mTouchSlop;
                }

                if (mIsDragging) {
                    //同樣的在確定要滑動的時候，也是通過回撥來實現的
                    mListener.onDrag(dx, dy);
                    mLastTouchX = x;
                    mLastTouchY = y;

                    if (null != mVelocityTracker) {
                        mVelocityTracker.addMovement(ev);
                    }
                }
                break;
            }

            case MotionEvent.ACTION_CANCEL: {
                // Recycle Velocity Tracker
                if (null != mVelocityTracker) {
                    mVelocityTracker.recycle();
                    mVelocityTracker = null;
                }
                break;
            }

            case MotionEvent.ACTION_UP: {
                if (mIsDragging) {
                    if (null != mVelocityTracker) {
                        mLastTouchX = getActiveX(ev);
                        mLastTouchY = getActiveY(ev);

                        // Compute velocity within the last 1000ms
                        mVelocityTracker.addMovement(ev);
                        //每秒移動多少個畫素點
                        mVelocityTracker.computeCurrentVelocity(1000);

                        //算移動速率的
                        final float vX = mVelocityTracker.getXVelocity(), vY = mVelocityTracker
                                .getYVelocity();

                        // If the velocity is greater than minVelocity, call
                        // listener
                        if (Math.max(Math.abs(vX), Math.abs(vY)) >= mMinimumVelocity) {
                            //回撥實現慣性
                            mListener.onFling(mLastTouchX, mLastTouchY, -vX,
                                    -vY);
                        }
                    }
                }

                // Recycle Velocity Tracker
                if (null != mVelocityTracker) {
                    mVelocityTracker.recycle();
                    mVelocityTracker = null;
                }
                break;
            }
        }

        return true;
    }
}

應該都能明白，我們看看那個介面到底是啥

/*******************************************************************************
 * Copyright 2011, 2012 Chris Banes.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
package uk.co.senab.photoview.gestures;

public interface OnGestureListener {

    public void onDrag(float dx, float dy);

    public void onFling(float startX, float startY, float velocityX,
                        float velocityY);

    public void onScale(float scaleFactor, float focusX, float focusY);

}

最後 再看看控制器裡這個介面是怎麼實現onDrag的，onFling就不分析了 差不多其實

 @Override
    public void onDrag(float dx, float dy) {
        if (mScaleDragDetector.isScaling()) {
            return; // Do not drag if we are already scaling
        }

        if (DEBUG) {
            LogManager.getLogger().d(LOG_TAG,
                    String.format("onDrag: dx: %.2f. dy: %.2f", dx, dy));
        }

        ImageView imageView = getImageView();
        mSuppMatrix.postTranslate(dx, dy);
        //滑動的時候也不要忘記檢測邊緣 防止留白
        checkAndDisplayMatrix();

        //這個地方就是做了一個巧妙的判斷，他要實現的功能就是：
        //如果你拖拽到了邊緣，還繼續拖拽的話 那就交給父view來處理，如果沒有到邊緣 那我們就繼續自己處理 繼續拖拽圖片了
        //想象一下我們把photoview放到viewpager的時候 就是這樣處理的
        ViewParent parent = imageView.getParent();
        if (mAllowParentInterceptOnEdge && !mScaleDragDetector.isScaling() && !mBlockParentIntercept) {
            if (mScrollEdge == EDGE_BOTH
                    || (mScrollEdge == EDGE_LEFT && dx >= 1f)
                    || (mScrollEdge == EDGE_RIGHT && dx <= -1f)) {
                if (null != parent)
                    parent.requestDisallowInterceptTouchEvent(false);
            }
        } else {
            if (null != parent) {
                parent.requestDisallowInterceptTouchEvent(true);
            }
        }
    }

到這我們的這篇部落格就基本結束了，其實這個開源photoview真的挺值得大家好好分析的，如果分析的好，你對android裡面 各種手勢監聽 matrix rectF
等等應該都能瞭如指掌了，以後遇到類似的問題 應該不會沒有頭緒了！