欢迎来访李梅博客,希望看的开心!

最新文章 标签集合 在线留言 申请友链 管理登录

当前位置:首页 > Android开发 > Android应用中实现手势控制图片缩放的完全攻略

Android应用中实现手势控制图片缩放的完全攻略

 

一、概述
现在app中,图片预览功能肯定是少不了的,用户基本已经形成条件反射,看到小图,点击看大图,看到大图两个手指开始进行放大,放大后,开始移动到指定部位~~~
我相信看图的整个步骤,大家或者说用户应该不希望被打断把~~~“我擦,竟然不能放大,什么玩意,卸了~~“ , "我擦,竟然不能移动,留有何用,卸了~~"。
哈~所以对于图片的预览,一来,我们要让用户爽;二来,我们作为开发者,也得知道如何实现~~~
想要做到图片支持多点触控,自由的进行缩放、平移,需要了解几个知识点:Matrix , GestureDetector , ScaleGestureDetector 以及事件分发机制,ps:不会咋办,不会你懂的。

二、Matrix
矩阵,看深入了都是3维矩阵的乘啊什么的,怪麻烦的~~
其实这么了解下就行了:
Matrix
数据结构:3维矩阵;
内部存储:new Float[9] ; 内部就是个一维数组,内部9个元素;可以进行setValues(float[] values)进行初始化
每个元素代表的意思:

1
2
3
4
5
{
    MSCALE_X, MSKEW_X, MTRANS_X, 
        MSKEW_Y, MSCALE_Y, MTRANS_Y, 
        MPERSP_0, MPERSP_1, MPERSP_2 
}; 

字面上,应该能看出来哪个代表x方向缩放,哪个代表垂直方向的偏移量吧~~有不认识的3个,没事,请无视。
操作
比如你想要设置matrix的偏移量为200,100
你可以这么写:

1
2
3
Matrix transMatrix = new Matrix();
    float[] values = new float[] { 1.0, 0, 200, 0, 1.0, 100, 0, 0, 1.0 };
    transMatrix.setValues(values);

如果需要在旋转30度,放大两倍~~
这么写其实怪麻烦的~~
Matrix提供了一些常用的API:例如我们可以这么写:

1
2
Matrix transMatrix = new Matrix();
    transMatrix.postTranslate(200, 100);

2016426154710002.jpg (444×355)

如何获取值:
当然了,我们对一个Matrix进行了各种操作,一会postScale,一会postTranslate;那么现在如何获得当前的缩放比例:
前面说setValues可以初始化,那么getValues就能拿到当前矩阵的值,拿到的是个一维数组,9个元素;再通过下标取对应值就可以。
比如我想知道现在x方向缩放比例:

1
2
3
4
5
public final float getScale()
  {
    scaleMatrix.getValues(matrixValues);
    return matrixValues[Matrix.MSCALE_X];
  }

好了,知道这些就够了~~
GestureDetector :
嗯,自己看API,能够捕捉到长按、双击什么的;用法会在例子中
ScaleGestureDetector:
嗯,有点像继承来的,其实不是的,独立的一个类~用于检测缩放的手势~~~用法会在例子中

三、实战
为了大家更好的理解,我会独立出每个功能,最后再整合到一起~~也方面大家对每个API的使用的学习。
1、自由的缩放
需求:当图片加载时,将图片在屏幕中居中;图片宽或高大于屏幕的,缩小至屏幕大小;自由对图片进行方法或缩小;
代码不是很长,直接贴代码了:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
package com.zhy.view;
  
import android.content.Context;
import android.graphics.Matrix;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.ScaleGestureDetector.OnScaleGestureListener;
import android.view.View;
import android.view.View.OnTouchListener;
import android.view.ViewTreeObserver;
import android.widget.ImageView;
  
public class ZoomImageView extends ImageView implements OnScaleGestureListener,
    OnTouchListener, ViewTreeObserver.OnGlobalLayoutListener
  
{
  private static final String TAG = ZoomImageView.class.getSimpleName();
    
  public static final float SCALE_MAX = 4.0f;
  /**
   * 初始化时的缩放比例,如果图片宽或高大于屏幕,此值将小于0
   */
  private float initScale = 1.0f;
  
  /**
   * 用于存放矩阵的9个值
   */
  private final float[] matrixValues = new float[9];
  
  private boolean once = true;
  
  /**
   * 缩放的手势检测
   */
  private ScaleGestureDetector mScaleGestureDetector = null;
  
  private final Matrix mScaleMatrix = new Matrix();
  
  public ZoomImageView(Context context)
  {
    this(context, null);
  }
  
  public ZoomImageView(Context context, AttributeSet attrs)
  {
    super(context, attrs);
    super.setScaleType(ScaleType.MATRIX);
    mScaleGestureDetector = new ScaleGestureDetector(context, this);
    this.setOnTouchListener(this);
  }
  
  @Override
  public boolean onScale(ScaleGestureDetector detector)
  {
    float scale = getScale();
    float scaleFactor = detector.getScaleFactor();
  
    if (getDrawable() == null)
      return true;
  
    /**
     * 缩放的范围控制
     */
    if ((scale < SCALE_MAX && scaleFactor > 1.0f)
        || (scale > initScale && scaleFactor < 1.0f))
    {
      /**
       * 最大值最小值判断
       */
      if (scaleFactor * scale < initScale)
      {
        scaleFactor = initScale / scale;
      }
      if (scaleFactor * scale > SCALE_MAX)
      {
        scaleFactor = SCALE_MAX / scale;
      }
      /**
       * 设置缩放比例
       */
      mScaleMatrix.postScale(scaleFactor, scaleFactor, getWidth() / 2,
          getHeight() / 2);
      setImageMatrix(mScaleMatrix);
    }
    return true;
  
  }
  
  @Override
  public boolean onScaleBegin(ScaleGestureDetector detector)
  {
    return true;
  }
  
  @Override
  public void onScaleEnd(ScaleGestureDetector detector)
  {
  }
  
  @Override
  public boolean onTouch(View v, MotionEvent event)
  {
    return mScaleGestureDetector.onTouchEvent(event);
  
  }
  
    
  /**
   * 获得当前的缩放比例
   *
   * @return
   */
  public final float getScale()
  {
    mScaleMatrix.getValues(matrixValues);
    return matrixValues[Matrix.MSCALE_X];
  }
  
  @Override
  protected void onAttachedToWindow()
  {
    super.onAttachedToWindow();
    getViewTreeObserver().addOnGlobalLayoutListener(this);
  }
  
  @SuppressWarnings("deprecation")
  @Override
  protected void onDetachedFromWindow()
  {
    super.onDetachedFromWindow();
    getViewTreeObserver().removeGlobalOnLayoutListener(this);
  }
  
  @Override
  public void onGlobalLayout()
  {
    if (once)
    {
      Drawable d = getDrawable();
      if (d == null)
        return;
      Log.e(TAG, d.getIntrinsicWidth() + " , " + d.getIntrinsicHeight());
      int width = getWidth();
      int height = getHeight();
      // 拿到图片的宽和高
      int dw = d.getIntrinsicWidth();
      int dh = d.getIntrinsicHeight();
      float scale = 1.0f;
      // 如果图片的宽或者高大于屏幕,则缩放至屏幕的宽或者高
      if (dw > width && dh <= height)
      {
        scale = width * 1.0f / dw;
      }
      if (dh > height && dw <= width)
      {
        scale = height * 1.0f / dh;
      }
      // 如果宽和高都大于屏幕,则让其按按比例适应屏幕大小
      if (dw > width && dh > height)
      {
        scale = Math.min(dw * 1.0f / width, dh * 1.0f / height);
      }
      initScale = scale;
      // 图片移动至屏幕中心
            mScaleMatrix.postTranslate((width - dw) / 2, (height - dh) / 2);
      mScaleMatrix
          .postScale(scale, scale, getWidth() / 2, getHeight() / 2);
      setImageMatrix(mScaleMatrix);
      once = false;
    }
  
  }
  
}

我们在onGlobalLayout的回调中,根据图片的宽和高以及屏幕的宽和高,对图片进行缩放以及移动至屏幕的中心。如果图片很小,那就正常显示,不放大了~
我们让OnTouchListener的MotionEvent交给ScaleGestureDetector进行处理

1
2
3
4
5
6
@Override
  public boolean onTouch(View v, MotionEvent event)
  {
    return mScaleGestureDetector.onTouchEvent(event);
  
  }

2、在onScale的回调中对图片进行缩放的控制,首先进行缩放范围的判断,然后设置mScaleMatrix的scale值
现在的效果:
小于屏幕的宽和高

大于屏幕的宽和高

真机录的效果不太好~~凑合看~
现在已经能够~~~随意的放大缩小了~~~
可是,可是,存在问题:
(1)缩放的中心点,我们设置是固定的,屏幕中间
(2)放大后,无法移动~
下面,我们先解决缩放的中心点问题,不能一直按屏幕中心么,像我这样的,我比较关注妹子的眼睛,我要放大那一块~~~
(1)设置缩放中心
(2)单纯的设置缩放中心
仅仅是设置中心很简单,直接修改下中心点 :

1
2
3
4
5
6
/**
       * 设置缩放比例
       */
      mScaleMatrix.postScale(scaleFactor, scaleFactor,
          detector.getFocusX(), detector.getFocusX());
      setImageMatrix(mScaleMatrix);

但是,随意的中心点放大、缩小,会导致图片的位置的变化,最终导致,图片宽高大于屏幕时,图片与屏幕间出现白边;图片小于屏幕,但是不居中。

3、控制缩放时图片显示的范围
所以我们在缩放的时候需要手动控制下范围:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/**
   * 在缩放时,进行图片显示范围的控制
   */
  private void checkBorderAndCenterWhenScale()
  {
  
    RectF rect = getMatrixRectF();
    float deltaX = 0;
    float deltaY = 0;
  
    int width = getWidth();
    int height = getHeight();
  
    // 如果宽或高大于屏幕,则控制范围
    if (rect.width() >= width)
    {
      if (rect.left > 0)
      {
        deltaX = -rect.left;
      }
      if (rect.right < width)
      {
        deltaX = width - rect.right;
      }
    }
    if (rect.height() >= height)
    {
      if (rect.top > 0)
      {
        deltaY = -rect.top;
      }
      if (rect.bottom < height)
      {
        deltaY = height - rect.bottom;
      }
    }
    // 如果宽或高小于屏幕,则让其居中
    if (rect.width() < width)
    {
      deltaX = width * 0.5f - rect.right + 0.5f * rect.width();
    }
    if (rect.height() < height)
    {
      deltaY = height * 0.5f - rect.bottom + 0.5f * rect.height();
    }
    Log.e(TAG, "deltaX = " + deltaX + " , deltaY = " + deltaY);
  
    mScaleMatrix.postTranslate(deltaX, deltaY);
  
  }
  
  /**
   * 根据当前图片的Matrix获得图片的范围
   *
   * @return
   */
  private RectF getMatrixRectF()
  {
    Matrix matrix = mScaleMatrix;
    RectF rect = new RectF();
    Drawable d = getDrawable();
    if (null != d)
    {
      rect.set(0, 0, d.getIntrinsicWidth(), d.getIntrinsicHeight());
      matrix.mapRect(rect);
    }
    return rect;
  }

在onScale里面记得调用:

1
2
3
4
5
6
7
/**
       * 设置缩放比例
       */
      mScaleMatrix.postScale(scaleFactor, scaleFactor,
          detector.getFocusX(), detector.getFocusY());
      checkBorderAndCenterWhenScale();
      setImageMatrix(mScaleMatrix);

这样就好了,可以自由的放大任何地方,并且不会出现边界出现白边,也能很好的让图片显示在屏幕中间(当图片宽或高小于屏幕);

贴下布局文件:

1
2
3
4
5
6
7
8
9
10
11
12
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent" >
  
  <com.zhy.view.ZoomImageView
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:scaleType="matrix"
    android:src="@drawable/xx" />
  
</RelativeLayout>

眼睛是心灵的窗户,咱们来放大看看,效果图:

 

四、进阶
1、自由的进行移动
下面继续完善我们的ImageView~~
首先加入放大后的移动~~
我们在onTouchEvent里面,加上移动的代码,当然了,必须长或宽大于屏幕才可以移动~~~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
@Override
  public boolean onTouch(View v, MotionEvent event)
  {
    mScaleGestureDetector.onTouchEvent(event);
  
    float x = 0, y = 0;
    // 拿到触摸点的个数
    final int pointerCount = event.getPointerCount();
    // 得到多个触摸点的x与y均值
    for (int i = 0; i < pointerCount; i++)
    {
      x += event.getX(i);
      y += event.getY(i);
    }
    x = x / pointerCount;
    y = y / pointerCount;
  
    /**
     * 每当触摸点发生变化时,重置mLasX , mLastY
     */
    if (pointerCount != lastPointerCount)
    {
      isCanDrag = false;
      mLastX = x;
      mLastY = y;
    }
      
  
    lastPointerCount = pointerCount;
  
    switch (event.getAction())
    {
    case MotionEvent.ACTION_MOVE:
      Log.e(TAG, "ACTION_MOVE");
      float dx = x - mLastX;
      float dy = y - mLastY;
        
      if (!isCanDrag)
      {
        isCanDrag = isCanDrag(dx, dy);
      }
      if (isCanDrag)
      {
        RectF rectF = getMatrixRectF();
        if (getDrawable() != null)
        {
          isCheckLeftAndRight = isCheckTopAndBottom = true;
          // 如果宽度小于屏幕宽度,则禁止左右移动
          if (rectF.width() < getWidth())
          {
            dx = 0;
            isCheckLeftAndRight = false;
          }
          // 如果高度小雨屏幕高度,则禁止上下移动
          if (rectF.height() < getHeight())
          {
            dy = 0;
            isCheckTopAndBottom = false;
          }
          mScaleMatrix.postTranslate(dx, dy);
          checkMatrixBounds();
          setImageMatrix(mScaleMatrix);
        }
      }
      mLastX = x;
      mLastY = y;
      break;
  
    case MotionEvent.ACTION_UP:
    case MotionEvent.ACTION_CANCEL:
      Log.e(TAG, "ACTION_UP");
      lastPointerCount = 0;
      break;
    }
  
    return true;
  }

首先我们拿到触摸点的数量,然后求出多个触摸点的平均值,设置给我们的mLastX , mLastY , 然后在移动的时候,得到dx ,dy 进行范围检查以后,调用mScaleMatrix.postTranslate进行设置偏移量,当然了,设置完成以后,还需要再次校验一下,不能把图片移动的与屏幕边界出现白边,校验完成后,调用setImageMatrix.
这里:需要注意一下,我们没有复写ACTION_DOWM,是因为,ACTION_DOWN在多点触控的情况下,只要有一个手指按下状态,其他手指按下不会再次触发ACTION_DOWN,但是多个手指以后,触摸点的平均值会发生很大变化,所以我们没有用到ACTION_DOWN。每当触摸点的数量变化,我们就会跟新当前的mLastX,mLastY.
下面是上面用到的两个私有方法,一个用于检查边界,一个用于判断是否是拖动的操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/**
   * 移动时,进行边界判断,主要判断宽或高大于屏幕的
   */
  private void checkMatrixBounds()
  {
    RectF rect = getMatrixRectF();
  
    float deltaX = 0, deltaY = 0;
    final float viewWidth = getWidth();
    final float viewHeight = getHeight();
    // 判断移动或缩放后,图片显示是否超出屏幕边界
    if (rect.top > 0 && isCheckTopAndBottom)
    {
      deltaY = -rect.top;
    }
    if (rect.bottom < viewHeight && isCheckTopAndBottom)
    {
      deltaY = viewHeight - rect.bottom;
    }
    if (rect.left > 0 && isCheckLeftAndRight)
    {
      deltaX = -rect.left;
    }
    if (rect.right < viewWidth && isCheckLeftAndRight)
    {
      deltaX = viewWidth - rect.right;
    }
    mScaleMatrix.postTranslate(deltaX, deltaY);
  }
  
  /**
   * 是否是推动行为
   *
   * @param dx
   * @param dy
   * @return
   */
  private boolean isCanDrag(float dx, float dy)
  {
    return Math.sqrt((dx * dx) + (dy * dy)) >= mTouchSlop;
  }

这样,我们就可以快乐的放大、缩小加移动了~~~
效果图:这次换个男人的图片,我们越狱的主角之一,TBug~

我们的缩放+移动搞定~~
2、双击放大与缩小
谈到双击事件,我们的GestureDetector终于要登场了,这哥们可以捕获双击事件~~
(1)GestureDetector的使用
因为GestureDetector设置监听器的话,方法一大串,而我们只需要onDoubleTap这个回调,所以我们准备使用它的一个内部类SimpleOnGestureListener,对接口的其他方法实现了空实现。
不过还有几个问题需要讨论下,才能开始我们的代码:
(1)我们双击尺寸如何变化?
我是这样的,根据当前的缩放值,如果是小于2的,我们双击直接到变为原图的2倍;如果是2,4之间的,我们双击直接为原图的4倍;其他状态也就是4倍,双击后还原到最初的尺寸。
如果你觉得这样不合适,可以根据自己的爱好调整。

我们双击变化,需要一个动画~~比如我们上例的演示图,图片很大,全屏显示的时候initScale=0.5左后,如果双击后变为2,也就是瞬间大了四倍,没有一个过渡的效果的话,给用户的感觉会特别差。所以,我们准备使用postDelay执行一个Runnable,Runnable中再次根据的当然的缩放值继续执行。
首先我们在构造方法中,完成对GestureDetector的初始化,以及设置onDoubleTap监听

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public ZoomImageView(Context context, AttributeSet attrs)
  {
    super(context, attrs);
    mScaleGestureDetector = new ScaleGestureDetector(context, this);
    mGestureDetector = new GestureDetector(context,
        new SimpleOnGestureListener()
        {
          @Override
          public boolean onDoubleTap(MotionEvent e)
          {
            if (isAutoScale == true)
              return true;
  
            float x = e.getX();
            float y = e.getY();
            Log.e("DoubleTap", getScale() + " , " + initScale);
            if (getScale() < SCALE_MID)
            {
              ZoomImageView.this.postDelayed(
                  new AutoScaleRunnable(SCALE_MID, x, y), 16);
              isAutoScale = true;
            } else if (getScale() >= SCALE_MID
                && getScale() < SCALE_MAX)
            {
              ZoomImageView.this.postDelayed(
                  new AutoScaleRunnable(SCALE_MAX, x, y), 16);
              isAutoScale = true;
            } else
            {
              ZoomImageView.this.postDelayed(
                  new AutoScaleRunnable(initScale, x, y), 16);
              isAutoScale = true;
            }
  
            return true;
          }
        });
    mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
    super.setScaleType(ScaleType.MATRIX);
    this.setOnTouchListener(this);
  }

当双击的时候,首先判断是否正在自动缩放,如果在,直接retrun ;
然后就进入了我们的if,如果当然是scale小于2,则通过view.发送一个Runnable进行执行;其他类似;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/**
   * 自动缩放的任务
   *
   * @author zhy
   *
   */
  private class AutoScaleRunnable implements Runnable
  {
    static final float BIGGER = 1.07f;
    static final float SMALLER = 0.93f;
    private float mTargetScale;
    private float tmpScale;
  
    /**
     * 缩放的中心
     */
    private float x;
    private float y;
  
    /**
     * 传入目标缩放值,根据目标值与当前值,判断应该放大还是缩小
     *
     * @param targetScale
     */
    public AutoScaleRunnable(float targetScale, float x, float y)
    {
      this.mTargetScale = targetScale;
      this.x = x;
      this.y = y;
      if (getScale() < mTargetScale)
      {
        tmpScale = BIGGER;
      } else
      {
        tmpScale = SMALLER;
      }
  
    }
  
    @Override
    public void run()
    {
      // 进行缩放
      mScaleMatrix.postScale(tmpScale, tmpScale, x, y);
      checkBorderAndCenterWhenScale();
      setImageMatrix(mScaleMatrix);
  
      final float currentScale = getScale();
      //如果值在合法范围内,继续缩放
      if (((tmpScale > 1f) && (currentScale < mTargetScale))
          || ((tmpScale < 1f) && (mTargetScale < currentScale)))
      {
        ZoomImageView.this.postDelayed(this, 16);
      } else//设置为目标的缩放比例
      {
        final float deltaScale = mTargetScale / currentScale;
        mScaleMatrix.postScale(deltaScale, deltaScale, x, y);
        checkBorderAndCenterWhenScale();
        setImageMatrix(mScaleMatrix);
        isAutoScale = false;
      }
  
    }
  }

代码写完了,我们依然需要把我们的event传给它,依然是在onTouch方法:

1
2
3
4
5
@Override
  public boolean onTouch(View v, MotionEvent event)
  {
    if (mGestureDetector.onTouchEvent(event))
      return true;

好了,双击放大与缩小的功能就搞定了,下面测试下~~~
效果图,终于可以用模拟器了~~

 

3、处理与ViewPager的冲突
直接把我们的图片作为ViewPager的Item,可想而知,肯定有冲突~~
(1)布局文件

1
2
3
4
5
6
7
8
9
10
11
12
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent" >
  
  <android.support.v4.view.ViewPager
    android:id="@+id/id_viewpager"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent" >
  </android.support.v4.view.ViewPager>
  
</RelativeLayout>

(2)Activity代码
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package com.zhy.zhy_scalegesturedetector02;
  
import android.app.Activity;
import android.os.Bundle;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
  
import com.zhy.view.ZoomImageView;
  
public class MainActivity extends Activity
{
  private ViewPager mViewPager;
  private int[] mImgs = new int[] { R.drawable.tbug, R.drawable.a,
      R.drawable.xx };
  private ImageView[] mImageViews = new ImageView[mImgs.length];
  
  @Override
  protected void onCreate(Bundle savedInstanceState)
  {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.vp);
      
    mViewPager = (ViewPager) findViewById(R.id.id_viewpager);
    mViewPager.setAdapter(new PagerAdapter()
    {
  
      @Override
      public Object instantiateItem(ViewGroup container, int position)
      {
        ZoomImageView imageView = new ZoomImageView(
            getApplicationContext());
        imageView.setImageResource(mImgs[position]);
        container.addView(imageView);
        mImageViews[position] = imageView;
        return imageView;
      }
  
      @Override
      public void destroyItem(ViewGroup container, int position,
          Object object)
      {
        container.removeView(mImageViews[position]);
      }
  
      @Override
      public boolean isViewFromObject(View arg0, Object arg1)
      {
        return arg0 == arg1;
      }
  
      @Override
      public int getCount()
      {
        return mImgs.length;
      }
    });
  
  }
}

现在直接运行,发现ViewPager好着呢,但是我们的图片放大以后,移动和ViewPager冲突了,又不能移动了~。。。擦擦擦。。。

(3)处理冲突
现在我们迅速的想一想,记得之前学习过事件分发机制,我们的ZoomImageView在ViewPager中,如果我们不想被拦截,那么如何做呢?
首先不想被拦截的条件是:我们的宽或高大于屏幕宽或高时,因为此时可以移动,我们不想被拦截。接下来,不想被拦截:
getParent().requestDisallowInterceptTouchEvent(true);
一行代码足以,如果你对事件分发中,不被拦截不清晰,可以参考:如何不被拦截 。
放在一起我们的代码就是:

1
2
3
4
5
6
7
8
9
10
11
12
13
switch (event.getAction())
    {
    case MotionEvent.ACTION_DOWN:
      if (rectF.width() > getWidth() || rectF.height() > getHeight())
      {
        getParent().requestDisallowInterceptTouchEvent(true);
      }
      break;
    case MotionEvent.ACTION_MOVE:
      if (rectF.width() > getWidth() || rectF.height() > getHeight())
      {
        getParent().requestDisallowInterceptTouchEvent(true);
      }

~当宽或高大于屏幕宽或高时,拖动效果认为是移动图片,反之则让ViewPager去处理
此时的效果:

ok,现在已经解决了和ViewPager的冲突,ps:尼玛不应该双击还能放大两次到4倍,,,,,好恶心。。。

(4)到达边界事件交给ViewPager处理
可能有些用户还希望,当图片到达边界时,不能再拖动的时候,能够把事件给ViewPager
那就在ACTION_MOVE中,判断当前已经到达边界,且还在拉的时候,事件交给ViewPager

1
2
3
4
5
6
7
8
9
10
11
12
13
14
if (isCanDrag)
      {
  
        if (getDrawable() != null)
        {
          if (getMatrixRectF().left == 0 && dx > 0)
          {
            getParent().requestDisallowInterceptTouchEvent(false);
          }
  
          if (getMatrixRectF().right == getWidth() && dx < 0)
          {
            getParent().requestDisallowInterceptTouchEvent(false);
          }

此时的效果:

好了,其实添加了这个之后,体验一般哈~~~

终于写完了,代码中可能存在BUG,发现问题,或者解决了发现的BUG时,希望可以直接在博客下面留言,也能够方便他人~~
到此,我们的Android 手势检测实战 打造支持缩放平移的图片预览效果 结束~~!

建议把双击放大到4倍的地方,注释掉一个If

1
2
3
4
5
6
7
//           else if (getScale() >= SCALE_MID
//               && getScale() < SCALE_MAX)
//           {
//             ZoomImageView.this.postDelayed(
//                 new AutoScaleRunnable(SCALE_MAX, x, y), 16);
//             isAutoScale = true;
//           } 

连续双击放大,感觉不爽,代码已经上传,我就不重传了,如果你也觉得不爽,可以自行注释。

除特别注明外,本站所有文章均为李梅 ’BLOG原创,转载请注明出处来自https://www.xslds.com/post/173.html

«   2019年9月   »
1
2345678
9101112131415
16171819202122
23242526272829
30
网站分类
  • (1).阿里云服务器【产品幸运券】
  • (2).阿里云服务器【产品幸运券】
  • 作者列表
    最新留言
    最近发表
    文章归档
    站点信息
    • 文章总数:234
    • 页面总数:4
    • 分类总数:22
    • 标签总数:522
    • 评论总数:605
    • 浏览总数:3946384

    分享:

    支付宝

    微信