android图片缩放手势检测类--ScaleGestureDetector

最新推荐文章于 2024-04-07 19:04:32 发布
最新推荐文章于 2024-04-07 19:04:32 发布
阅读量937 收藏 1
点赞数
分类专栏： android Android页面控件
本文为博主原创文章，未经博主允许不得转载。安卓五千源码下载--https://blog.csdn.net/wuqilianga/article/details/89185887
本文链接：https://blog.csdn.net/wuqilianga/article/details/79354386
版权


此类位于 android.view包下，图片放大缩小的辅助类

源码如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package android.view;

import android.content.Context;
import android.os.Handler;

public class ScaleGestureDetector {
    public ScaleGestureDetector(Context context, ScaleGestureDetector.OnScaleGestureListener listener) {
        throw new RuntimeException("Stub!");
    }

    public ScaleGestureDetector(Context context, ScaleGestureDetector.OnScaleGestureListener listener, Handler handler) {
        throw new RuntimeException("Stub!");
    }

    public boolean onTouchEvent(MotionEvent event) {
        throw new RuntimeException("Stub!");
    }

    public void setQuickScaleEnabled(boolean scales) {
        throw new RuntimeException("Stub!");
    }

    public boolean isQuickScaleEnabled() {
        throw new RuntimeException("Stub!");
    }

    public void setStylusScaleEnabled(boolean scales) {
        throw new RuntimeException("Stub!");
    }

    public boolean isStylusScaleEnabled() {
        throw new RuntimeException("Stub!");
    }

    public boolean isInProgress() {
        throw new RuntimeException("Stub!");
    }

    public float getFocusX() {
        throw new RuntimeException("Stub!");
    }

    public float getFocusY() {
        throw new RuntimeException("Stub!");
    }

    public float getCurrentSpan() {
        throw new RuntimeException("Stub!");
    }

    public float getCurrentSpanX() {
        throw new RuntimeException("Stub!");
    }

    public float getCurrentSpanY() {
        throw new RuntimeException("Stub!");
    }

    public float getPreviousSpan() {
        throw new RuntimeException("Stub!");
    }

    public float getPreviousSpanX() {
        throw new RuntimeException("Stub!");
    }

    public float getPreviousSpanY() {
        throw new RuntimeException("Stub!");
    }

    public float getScaleFactor() {
        throw new RuntimeException("Stub!");
    }

    public long getTimeDelta() {
        throw new RuntimeException("Stub!");
    }

    public long getEventTime() {
        throw new RuntimeException("Stub!");
    }

    public static class SimpleOnScaleGestureListener implements ScaleGestureDetector.OnScaleGestureListener {
        public SimpleOnScaleGestureListener() {
            throw new RuntimeException("Stub!");
        }

        public boolean onScale(ScaleGestureDetector detector) {
            throw new RuntimeException("Stub!");
        }

        public boolean onScaleBegin(ScaleGestureDetector detector) {
            throw new RuntimeException("Stub!");
        }

        public void onScaleEnd(ScaleGestureDetector detector) {
            throw new RuntimeException("Stub!");
        }
    }

    public interface OnScaleGestureListener {
        boolean onScale(ScaleGestureDetector var1);

        boolean onScaleBegin(ScaleGestureDetector var1);

        void onScaleEnd(ScaleGestureDetector var1);
    }
}


Android通过ScaleGestureDetector实现图片缩放

介绍请参考：http://blog.csdn.net/true100/article/details/51141496


下边是一个github作者用其实现漫画浏览器的效果：github链接

xml布局：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

<zhan.scrollzoomlist.ScrollZoomListView
    android:id="@+id/list"
    app:min_zoom_scale="0.4"
    app:max_zoom_scale="2.0"
    app:zoom_scale_duration="300"
    app:zoom_to_small_scale_duration="500"
    app:zoom_to_small_times="6"
    app:normal_scale="1.0"
    app:zoom_scale="2.0"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>



</RelativeLayout>

调用的activity：

package zhan.scollzoomlistview;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import com.bumptech.glide.Glide;
import java.util.ArrayList;
import java.util.List;
import zhan.scrollzoomlist.ScrollZoomListView;

public class MainActivity extends AppCompatActivity {

  private List<Integer> mData = new ArrayList<>();
  private ScrollZoomListView list;

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    //设置无标题
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    //设置全屏
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
        WindowManager.LayoutParams.FLAG_FULLSCREEN);


    setContentView(R.layout.activity_main);

    mData.clear();
    mData.add(R.mipmap.comic1);
    mData.add(R.mipmap.comic2);
    mData.add(R.mipmap.comic3);
    mData.add(R.mipmap.comic4);
    mData.add(R.mipmap.comic5);
    mData.add(R.mipmap.comic6);
    mData.add(R.mipmap.comic7);
    mData.add(R.mipmap.comic8);
    mData.add(R.mipmap.comic9);
    mData.add(R.mipmap.comic10);

    list = (ScrollZoomListView) findViewById(R.id.list);

    MyAdapter adapter = new MyAdapter();
    adapter.setData(mData);
    list.setAdapter(adapter);
  }

  private class MyAdapter extends BaseAdapter {

    private List<Integer> mData;

    public void setData(List<Integer> data) {
      mData = data;
      notifyDataSetChanged();
    }

    @Override public int getCount() {
      return mData == null ? 0 : mData.size();
    }

    @Override public Object getItem(int position) {
      return mData.get(position);
    }

    @Override public long getItemId(int position) {
      return position + 1000;
    }

    @Override public View getView(int position, View convertView, ViewGroup parent) {

      MyHolder holder;

      if (convertView == null) {
        convertView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item, parent, false);
        holder = new MyHolder();
        holder.picIv = (ImageView) convertView.findViewById(R.id.pic_iv);
        convertView.setTag(holder);
      } else {
        holder = (MyHolder) convertView.getTag();
      }

      Glide.with(parent.getContext())
          .load(mData.get(position))
          .dontAnimate()
          .into(holder.picIv);

      return convertView;
    }
  }

  static class MyHolder {
    public ImageView picIv;
  }
}

重要的滚动缩放listview

package zhan.scrollzoomlist;

import android.animation.Animator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.PointF;
import android.support.annotation.NonNull;
import android.support.v4.view.GestureDetectorCompat;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.animation.DecelerateInterpolator;
import android.widget.ListView;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * Created by ruzhan on 17/1/9.
 */
public class ScrollZoomListView extends ListView {

  private static final int INVALID_POINTER_ID = -1;

  private static final float DEFAULT_MIN_ZOOM_SCALE = 0.4f;
  private static final float DEFAULT_MAX_ZOOM_SCALE = 2.0f;

  private static final float DEFAULT_NORMAL_SCALE = 1.0f;
  private static final float DEFAULT_ZOOM_SCALE = 2.0f;

  private static final int DEFAULT_ZOOM_TO_SMALL_TIMES = 6;
  private static final int DEFAULT_ZOOM_SCALE_DURATION = 300;
  private static final int DEFAULT_ZOOM_TO_SMALL_SCALE_DURATION = 500;

  private static final int UN_LOADED_POINT = 10000;
  private static final int LOADED_POINT = 10001;

  private static int mActivePointerId = INVALID_POINTER_ID;

  private float mScaleFactor = DEFAULT_NORMAL_SCALE;
  private float mLastScale = DEFAULT_NORMAL_SCALE;

  private int mLoadedPointFlag = UN_LOADED_POINT;

  private float mMinZoomScale;
  private float mMaxZoomScale;

  private float mNormalScale;
  private float mZoomScale;

  private int mZoomToSmallTimes;
  private int mZoomScaleDuration;
  private int mZoomToSmallScaleDuration;

  private ScaleGestureDetector mScaleDetector;
  private GestureDetectorCompat mGestureDetectorCompat;

  private float maxWidth = 0.0f;
  private float maxHeight = 0.0f;

  private float mLastTouchX;
  private float mLastTouchY;

  private float mTranslateX;
  private float mTranslateY;

  private float mListViewWidth;
  private float mListViewHeight;

  private float mCenterX;
  private float mCenterY;

  private boolean isScaling = false;
  private boolean isPointerDown = false;

  private ValueAnimator mZoomValueAnimator;

  //synchronous ListView Zoom ScaleGestureDetector
  private List<ScaleGestureDetector.SimpleOnScaleGestureListener> mOnScaleGestureListeners = new ArrayList<>();

  //synchronous ListView Zoom GestureDetector
  private List<GestureDetector.SimpleOnGestureListener> mSimpleOnGestureListeners = new ArrayList<>();

  //synchronous ListView Zoom Animation
  private List<OnListViewZoomListener> mOnListViewZoomListeners = new ArrayList<>();

  private LinkedList<PointF> mLinkPoints = new LinkedList<>();

  public ScrollZoomListView(Context context) {
    this(context, null);
  }

  public ScrollZoomListView(Context context, AttributeSet attr) {
    super(context, attr);
    init(attr);
  }

  private void init(AttributeSet attr) {
    mScaleDetector = new ScaleGestureDetector(getContext(), new ScaleListener());
    mGestureDetectorCompat =
        new GestureDetectorCompat(getContext(), new ScrollReaderViewGestureListener());

    TypedArray a = getContext().obtainStyledAttributes(attr, R.styleable.ScrollZoomListView, 0, 0);

    mMinZoomScale =
        a.getFloat(R.styleable.ScrollZoomListView_min_zoom_scale, DEFAULT_MIN_ZOOM_SCALE);
    mMaxZoomScale =
        a.getFloat(R.styleable.ScrollZoomListView_max_zoom_scale, DEFAULT_MAX_ZOOM_SCALE);
    mNormalScale = a.getFloat(R.styleable.ScrollZoomListView_normal_scale, DEFAULT_NORMAL_SCALE);
    mZoomScale = a.getFloat(R.styleable.ScrollZoomListView_zoom_scale, DEFAULT_ZOOM_SCALE);

    mZoomToSmallTimes = a.getInteger(R.styleable.ScrollZoomListView_zoom_to_small_times,
        DEFAULT_ZOOM_TO_SMALL_TIMES);
    mZoomScaleDuration = a.getInteger(R.styleable.ScrollZoomListView_zoom_scale_duration,
        DEFAULT_ZOOM_SCALE_DURATION);
    mZoomToSmallScaleDuration =
        a.getInteger(R.styleable.ScrollZoomListView_zoom_to_small_scale_duration,
            DEFAULT_ZOOM_TO_SMALL_SCALE_DURATION);

    a.recycle();
  }

  @Override protected void onDetachedFromWindow() {
    super.onDetachedFromWindow();

    if (mZoomValueAnimator != null) {
      mZoomValueAnimator.cancel();
    }

    //remove all listener
    removeOnScaleGestureListeners();
    removeOnSimpleOnGestureListeners();
    removeOnListViewZoomListeners();
  }

  @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

    mListViewWidth = MeasureSpec.getSize(widthMeasureSpec);
    mListViewHeight = MeasureSpec.getSize(heightMeasureSpec);

    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  }

  @Override public boolean onTouchEvent(@NonNull MotionEvent ev) {

    mScaleDetector.onTouchEvent(ev);

    mGestureDetectorCompat.onTouchEvent(ev);

    int action = ev.getAction();
    switch (action & MotionEvent.ACTION_MASK) {
      case MotionEvent.ACTION_DOWN: {

        isPointerDown = false;

        mLastTouchX = ev.getX();
        mLastTouchY = ev.getY();

        mActivePointerId = ev.getPointerId(0);
        break;
      }

      case MotionEvent.ACTION_POINTER_DOWN: {

        isPointerDown = true;
        break;
      }

      case MotionEvent.ACTION_MOVE: {

        int pointerIndex = ev.findPointerIndex(mActivePointerId);

        float x, y;

        try {

          x = ev.getX(pointerIndex);
          y = ev.getY(pointerIndex);
        } catch (IllegalArgumentException ex) {
          ex.printStackTrace();

          return super.onTouchEvent(ev);
        }

        float dx = (x - mLastTouchX);
        float dy = (y - mLastTouchY);

        //ACTION_POINTER_DOWN ListView more distance * 6
        if (isPointerDown) {
          dx = dx * mZoomToSmallTimes;
          dy = dy * mZoomToSmallTimes;
        }

        if (isScaling) {  //ListView status is scaling
          float offsetX = mCenterX * (mLastScale - mScaleFactor);
          float offsetY = mCenterY * (mLastScale - mScaleFactor);

          //mTranslateX += offsetX;
          //mTranslateY += offsetY;

          //checkPointF(UN_LOADED_POINT, offsetX, offsetY);

          //mLastScale = mScaleFactor;
        } else if (mScaleFactor > mNormalScale) {   //ListView not scaling, move ...
          mTranslateX += dx;
          mTranslateY += dy;

          checkPointF(UN_LOADED_POINT, dx, dy);

          correctTranslateValue();
        }

        mLastTouchX = x;
        mLastTouchY = y;

        invalidate();
        break;
      }

      case MotionEvent.ACTION_UP:
      case MotionEvent.ACTION_CANCEL: {

        mActivePointerId = INVALID_POINTER_ID;

        break;
      }

      case MotionEvent.ACTION_POINTER_UP: {

        int pointerIndex = (action & MotionEvent.ACTION_POINTER_INDEX_MASK)
            >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
        int pointerId = ev.getPointerId(pointerIndex);

        if (pointerId == mActivePointerId) {
          int newPointerIndex = pointerIndex == 0 ? 1 : 0;
          mLastTouchX = ev.getX(newPointerIndex);
          mLastTouchY = ev.getY(newPointerIndex);
          mActivePointerId = ev.getPointerId(newPointerIndex);
        }

        break;
      }
    }

    return super.onTouchEvent(ev);
  }

  private void correctTranslateValue() {
    if (mTranslateX > 0.0f) {
      mTranslateX = 0.0f;
    } else if (mTranslateX < maxWidth) {
      mTranslateX = maxWidth;
    }

    if (mTranslateY > 0.0f) {
      mTranslateY = 0.0f;
    } else if (mTranslateY < maxHeight) {
      mTranslateY = maxHeight;
    }
  }

  @Override protected void dispatchDraw(@NonNull Canvas canvas) {

    canvas.save(Canvas.MATRIX_SAVE_FLAG);
    canvas.translate(mTranslateX, mTranslateY);
    canvas.scale(mScaleFactor, mScaleFactor);

    super.dispatchDraw(canvas);

    canvas.restore();
  }

  private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
    @Override public boolean onScaleBegin(ScaleGestureDetector detector) {

      for (ScaleGestureDetector.OnScaleGestureListener listener : mOnScaleGestureListeners) {
        listener.onScaleBegin(detector);
      }

      return super.onScaleBegin(detector);
    }

    @Override public boolean onScale(ScaleGestureDetector detector) {

      mScaleFactor *= detector.getScaleFactor();

      float minFactor = Math.min(mScaleFactor, mMaxZoomScale);
      mScaleFactor = Math.max(mMinZoomScale, minFactor);

      maxWidth = mListViewWidth - (mListViewWidth * mScaleFactor);
      maxHeight = mListViewHeight - (mListViewHeight * mScaleFactor);

      mCenterX = detector.getFocusX();
      mCenterY = detector.getFocusY();

      float offsetX = mCenterX * (mLastScale - mScaleFactor);
      float offsetY = mCenterY * (mLastScale - mScaleFactor);

      mTranslateX += offsetX;
      mTranslateY += offsetY;

      checkPointF(UN_LOADED_POINT, offsetX, offsetY);

      mLastScale = mScaleFactor;

      isScaling = true;

      invalidate();

      for (ScaleGestureDetector.OnScaleGestureListener listener : mOnScaleGestureListeners) {
        listener.onScale(detector);
      }
      return true;
    }

    @Override public void onScaleEnd(ScaleGestureDetector detector) {

      if (mScaleFactor < mNormalScale) {
        zoomList(mScaleFactor, mNormalScale, mZoomToSmallScaleDuration, LOADED_POINT);
      }

      isScaling = false;

      for (ScaleGestureDetector.OnScaleGestureListener listener : mOnScaleGestureListeners) {
        listener.onScaleEnd(detector);
      }
    }
  }

  private class ScrollReaderViewGestureListener extends GestureDetector.SimpleOnGestureListener {

    @Override
    public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {

      //list view scroll call back... to outside
      for (GestureDetector.SimpleOnGestureListener listener : mSimpleOnGestureListeners) {
        listener.onScroll(e1, e2, distanceX, distanceY);
      }

      return super.onScroll(e1, e2, distanceX, distanceY);
    }

    @Override public boolean onSingleTapConfirmed(MotionEvent e) {  // single click event,double call no call single

      for (GestureDetector.SimpleOnGestureListener listener : mSimpleOnGestureListeners) {
        listener.onSingleTapConfirmed(e);
      }
      return super.onSingleTapConfirmed(e);
    }

    @Override public boolean onDoubleTap(MotionEvent e) {  //double click event

      if (mNormalScale < mScaleFactor) {
        zoomList(mScaleFactor, mNormalScale, mZoomScaleDuration, LOADED_POINT);

      } else if (mScaleFactor == mNormalScale) {

        mCenterX = e.getX();
        mCenterY = e.getY();

        zoomList(mScaleFactor, mZoomScale, mZoomScaleDuration, UN_LOADED_POINT);
      }

      for (GestureDetector.SimpleOnGestureListener listener : mSimpleOnGestureListeners) {
        listener.onDoubleTap(e);
      }
      return super.onDoubleTap(e);
    }
  }

  //let ListView zoom func
  private void zoomList(float startValue, float endValue, int duration, final int loadedPointFlag) {
    if (mZoomValueAnimator == null) {
      mZoomValueAnimator = new ValueAnimator();
      mZoomValueAnimator.setInterpolator(new DecelerateInterpolator());

      mZoomValueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override public void onAnimationUpdate(ValueAnimator animation) {

          mScaleFactor = (Float) animation.getAnimatedValue();

          float dx = mCenterX * (mLastScale - mScaleFactor);
          float dy = mCenterY * (mLastScale - mScaleFactor);

          PointF pointF = checkPointF(loadedPointFlag, dx, dy);

          if(pointF != null) {
            dx = -pointF.x;
            dy = -pointF.y;
          }

          mTranslateX += dx;
          mTranslateY += dy;


          maxWidth = mListViewWidth - (mListViewWidth * mScaleFactor);
          maxHeight = mListViewHeight - (mListViewHeight * mScaleFactor);

          correctZoomTranslateValue();

          invalidate();

          mLastScale = mScaleFactor;

          for (OnListViewZoomListener listener : mOnListViewZoomListeners) {
            listener.onListViewZoomUpdate(animation, mTranslateX, mTranslateY,
                mScaleFactor, mScaleFactor);
          }
        }
      });

      mZoomValueAnimator.addListener(new Animator.AnimatorListener() {
        @Override public void onAnimationStart(Animator animation) {
          isScaling = true;

          for (OnListViewZoomListener listener : mOnListViewZoomListeners) {
            listener.onListViewStart();
          }
        }

        @Override public void onAnimationEnd(Animator animation) {
          isScaling = false;

          mLoadedPointFlag = loadedPointFlag == UN_LOADED_POINT ? LOADED_POINT : UN_LOADED_POINT;

          for (OnListViewZoomListener listener : mOnListViewZoomListeners) {
            listener.onListViewCancel();
          }
        }

        @Override public void onAnimationCancel(Animator animation) {
          isScaling = false;

          for (OnListViewZoomListener listener : mOnListViewZoomListeners) {
            listener.onListViewCancel();
          }
        }

        @Override public void onAnimationRepeat(Animator animation) {

        }
      });
    }

    if (!mZoomValueAnimator.isRunning()) {
      mZoomValueAnimator.setFloatValues(startValue, endValue);
      mZoomValueAnimator.setDuration(duration);
      mZoomValueAnimator.start();
    }
  }

  private void correctZoomTranslateValue() {
    if (mTranslateX > 0.0f) { //zoom +

      if (mScaleFactor >= mNormalScale) {  //params correct
        mTranslateX = 0.0f;
      }
    } else if (mTranslateX < maxWidth) { //zoom -

      if (mScaleFactor >= mNormalScale) { //params correct
        mTranslateX = maxWidth;
      }
    }

    if (mTranslateY > 0.0f) { //zoom +

      if (mScaleFactor >= mNormalScale) {  //params correct
        mTranslateY = 0.0f;
      }
    } else if (mTranslateY < maxHeight) { //zoom -

      if (mScaleFactor >= mNormalScale) { //params correct
        mTranslateY = maxHeight;
      }
    }
  }

  private void putPointF(float dx, float dy) {
    if(mLoadedPointFlag == UN_LOADED_POINT) {
      PointF pointF = new PointF(dx, dy);
      mLinkPoints.addFirst(pointF);
    }
  }

  private PointF getPointF() {
    if(mLoadedPointFlag == LOADED_POINT) {
      return mLinkPoints.getLast();
    }

    return null;
  }

  private PointF checkPointF(int loadedPointFlag, float dx, float dy) {
    PointF pointF = null;

    if(loadedPointFlag == UN_LOADED_POINT) {
      putPointF(dx, dy);

    }else if(loadedPointFlag == LOADED_POINT) {
      pointF = getPointF();

    }else {
      throw new RuntimeException("ZoomListView loaded points error ! ! !");
    }
    return pointF;
  }

  public float getMinZoomScale() {
    return mMinZoomScale;
  }

  public void setMinZoomScale(float mMinZoomScale) {
    this.mMinZoomScale = mMinZoomScale;
  }

  public float getMaxZoomScale() {
    return mMaxZoomScale;
  }

  public void setMaxZoomScale(float mMaxZoomScale) {
    this.mMaxZoomScale = mMaxZoomScale;
  }

  public float getNormalScale() {
    return mNormalScale;
  }

  public void setNormalScale(float mNormalScale) {
    this.mNormalScale = mNormalScale;
  }

  public float getZoomScale() {
    return mZoomScale;
  }

  public void setZoomScale(float mZoomScale) {
    this.mZoomScale = mZoomScale;
  }

  public int getZoomToSmallTimes() {
    return mZoomToSmallTimes;
  }

  public void setZoomToSmallTimes(int mZoomToSmallTimes) {
    this.mZoomToSmallTimes = mZoomToSmallTimes;
  }

  public int getZoomScaleDuration() {
    return mZoomScaleDuration;
  }

  public void setZoomScaleDuration(int mZoomScaleDuration) {
    this.mZoomScaleDuration = mZoomScaleDuration;
  }

  public void addOnScaleGestureListener(ScaleGestureDetector.SimpleOnScaleGestureListener listener) {
    if(listener != null) {
      if(!mOnScaleGestureListeners.contains(listener)) {
        mOnScaleGestureListeners.add(listener);
      }
    }
  }

  public void removeOnScaleGestureListener(ScaleGestureDetector.SimpleOnScaleGestureListener listener) {
    if(listener != null) {
      if(mOnScaleGestureListeners.contains(listener)) {
        mOnScaleGestureListeners.remove(listener);
      }
    }
  }

  public void removeOnScaleGestureListeners() {
    while (!mOnScaleGestureListeners.isEmpty()) {
      mOnScaleGestureListeners.remove(0);
    }
  }

  public void setSimpleOnGestureListener(GestureDetector.SimpleOnGestureListener listener) {
    if(listener != null) {
      if(!mSimpleOnGestureListeners.contains(listener)) {
        mSimpleOnGestureListeners.add(listener);
      }
    }
  }

  public void removeOnSimpleOnGestureListener(GestureDetector.SimpleOnGestureListener listener) {
    if(listener != null) {
      if(mSimpleOnGestureListeners.contains(listener)) {
        mSimpleOnGestureListeners.remove(listener);
      }
    }
  }

  public void removeOnSimpleOnGestureListeners() {
    while (!mSimpleOnGestureListeners.isEmpty()) {
      mSimpleOnGestureListeners.remove(0);
    }
  }

  public void setOnListViewZoomListener(OnListViewZoomListener listener) {
    if(listener != null) {
      if(!mOnListViewZoomListeners.contains(listener)) {
        mOnListViewZoomListeners.add(listener);
      }
    }
  }

  public void removeOnListViewZoomListener(OnListViewZoomListener listener) {
    if(listener != null) {
      if(mOnListViewZoomListeners.contains(listener)) {
        mOnListViewZoomListeners.remove(listener);
      }
    }
  }

  public void removeOnListViewZoomListeners() {
    while (!mOnListViewZoomListeners.isEmpty()) {
      mOnListViewZoomListeners.remove(0);
    }
  }

  public interface OnListViewZoomListener {

    void onListViewZoomUpdate(ValueAnimator animation, float translateX, float translateY,
        float scaleX, float scaleY);

    void onListViewStart();

    void onListViewCancel();
  }
}

attrs.xml中的自定义元素：

<?xml version="1.0" encoding="utf-8"?>
<resources>

  <declare-styleable name="ScrollZoomListView">

    <attr name="min_zoom_scale" format="float" />
    <attr name="max_zoom_scale" format="float" />
    <attr name="normal_scale" format="float" />
    <attr name="zoom_scale" format="float" />

    <attr name="zoom_to_small_times" format="integer" />
    <attr name="zoom_scale_duration" format="integer" />
    <attr name="zoom_to_small_scale_duration" format="integer" />

  </declare-styleable>



</resources>


类似此类的多点触控和手势识别还有很多，请自行搜索[android 多点触控和手势识别]学习






当富网络
关注
专栏目录
Android-一个Android图片缩放查看控件支持手势
08-13
`GestureDetector`用于处理单指滑动和点击，而`ScaleGestureDetector`则用于检测缩放手势，通过监听器回调来响应这些手势。 3. **图片缩放** 图片的缩放通常涉及到矩阵操作。Android的`Matrix`类可以用来改变图像...
Android 手势检测实战 打造支持缩放的图片预览效果
01-09
对于图片缩放，我们还需要`ScaleGestureDetector`类，它用于处理 pinch-to-zoom（捏合缩放）的手势。 实现这个功能的第一步是创建`GestureDetector`和`ScaleGestureDetector`的实例。在`GestureDetector`中，我们...
Android应用开发基础篇（16）-----ScaleGestureDetector（缩放手势检测）
weixin_34205826的博客
03-11 565
一、概述       ScaleGestureDetector这个类是专门用来检测两个手指在屏幕上做缩放的手势用的，最简单的应用就是用来缩放图片或者缩放网页。 二、要求      利用ScaleGestureDetector这个类实现图片缩放。 三、实现      新建工程MyScale，修改main.xml文件，在里面添加一个Button和一个SurfaceView，如下： ...
android的ScaleGestureDetector缩放类详解
weixin_30298497的博客
12-03 253
文章由多出组合，它们来自： http://elvajxw.iteye.com/blog/1308452 http://www.cnblogs.com/lknlfy/archive/2012/03/11/2390274.html 类概述 根据接收的 MotionEvent,侦测由多个触点（多点触控）引发的变形手势。callback 方法ScaleGestureDetect...
Android ScaleGestureDetector缩放手势识别
热门推荐
qq402164452的博客
06-14 1万+
ScaleGestureDetector在Android中对于手势识别操作可以使用GestureDetector类来进行处理，对于缩放手势，则提供了对应的ScaleGestureDetector类。 public class ScaleGestureDetector extends Object ScaleGestureDetector 使用类内置的MotionEvents来识别探测缩
Android 利用ScaleGestureDetector实现图片放大、缩小，单击双击操作
TLuffy的博客
06-14 3791
ScaleGestureDetector 用于处理缩放的工具类，用法与GestureDetector类似，都是通过onTouchEvent()关联相应的MotionEvent的。使用该类时，用户需要传入一个完整的连续不断地motion事件（包含ACTION_DOWN,ACTION_MOVE和ACTION_UP事件）。 下面贴一个仿微信朋友圈图片处理的工具类，复制可以直接用 /** * 自定义手势放...
Android ScaleGestureDetector
elvaweijiye的博客
12-13 168
Android ScaleGestureDetector http://www.eoeandroid.com/forum.php?mod=viewthread&amp;tid=82829&amp;fromuid=589037     类概述        根据接收的 MotionEvent,  侦测由多个触点（多点触控）引发的变形手势。callback 方法 ScaleGestu...
Android 图片缩放和多点触摸-IT计算机-毕业设计.zip
04-05
在Android平台上，图片缩放和多点触摸是两个重要的交互技术，尤其对于图像查看器、地图应用等场景至关重要。这份毕业设计的源码Demo旨在帮助学生深入理解和掌握这两个功能的实现，为论文撰写提供实际操作案例。 ...
Android 图片浏览全屏缩放-SmoothImageDemo.rar
10-14
在Android应用开发中，图片浏览和缩放是一个常见的需求，特别是在社交、电商或者媒体类应用中。本项目"Android 图片浏览全屏缩放-SmoothImageDemo"提供了一个高效且用户体验良好的解决方案，旨在帮助开发者实现类似...
Android GestureDetector ScaleGestureDetector
旧路
06-28 1017
&nbsp; &nbsp; &nbsp; &nbsp;Android代码中给我们提供大量的帮助类来方便我们的使用。今天咱们就来看下手势帮助类GestureDetector、ScaleGestureDetector。 一、GestureDetector &nbsp; &nbsp; &nbsp; &nbsp;Android手机屏幕上，当咱们触摸屏幕的时候，会产生许多手势事件，如down，up，...
Android ScaleGestureDetector检测双指缩放Bitmap基于Matrix动画移动到双指捏合中心点ImageView区域中心，Kotlin
Zhang Phil
01-25 424
需要注意的，因为在xml布局里面特别设置了ImageView的高度为wrap_content，手指在屏幕触点的位置是放大镜里面放大图片后准确圆心位置，但是，如果ImageView设置成match_parent，则因为ImageView里面的Bitmap被缩放(此处Bitmap其实小于ImageView，被拉伸了)，拉伸后的Bitmap水平方向坐标与ImageView一直重合，但竖直方向，Bitmap坐标与ImageView不一致，会造成一种现象，手指触点放大镜放大后，水平方向是正确的，但竖直方向有偏移量。
Android 手把手进阶自定义View（十二）- 缩放手势检测 ScaleGestureDetector
lerendan的博客
04-01 1399
一、前言 Android 缩放手势检测 ScaleGestureDetector，在大多数的情况下缩放手势都不是单独存在的，需要配合其它的手势来使用，如果是用在自定义的控件上，则需要配合 Matrix 相关内容使用起来可能会更加方便。缩放手势最常见于以下的一些应用场景中，例如：图片浏览，网页缩放、地图等。 二、缩放手势检测 缩放手势检测同样是官方提供的手势检测工具，它的使用方式的 Ge...
Android手势识别GestureDetector和ScaleGestureDetector介绍与使用，以自定义一个可拖拽拉伸的ImageView为例
最新发布
阿飞的博客
04-07 2256
GestureDetector主要用于检测单指手势，例如单击、长按、滑动等，不支持多指手势。用于检测缩放手势，即双指捏合或者扩张的手势。它提供了 onScale() 和 onScaleBegin() 等回调方法来处理缩放手势的开始、进行中和结束时的事件。首先，我们可以直接继承 ImageView，并通过 Matrix 来控制图片的移动和拉伸。其次，使用 GestureDetector 监听移动的相关事件，使用 ScaleGestureDetector 监听拉伸的相关事件。
ScaleGestureDetector之手势缩放
Vegetable的博客
04-07 769
概述 　　根据接收的MotionEvent, 侦测由多个触点（多点触控）引发的变形手势。callback方法 ScaleGestureDetector.OnScaleGestureListener 会在特定手势事件发生时通知用户。该类仅能和Touch事件引发的MotionEvent配合使用。使用该类需要 　　为你的View创建ScaleGestureDetector 实例 　　确保在on
Android手势识别类，GestureDetector，ScaleGestureDetector
m0_57150356的博客
11-14 1371
Android程序使用中会有很多的手势，双击、长按、滑动、缩放等，我们可以通过手势识别类GestureDetector，ScaleGestureDetector进行识别。
Android 手势—— GestureDetector 和 SimpleOnScaleGestureListener (手势缩放)
小牧在一直在学习,在前进的道路上大家一起学习，进步。
09-23 2331
GestureDetector 的作用： 检测各种手势和事件，使用的使用一般和onTouchEvent 方法结合在一起使用 下面主要说的内容是GestureDetector 和ScaleGestureDetector 1GestureDetector 里面有一些回调接口下面说下 1.1OnGestureListener 这个是接口，实现的时候里面的方法会自动生成， 1.2SimpleOnGestureListener 这个是静态的里面的方法需要自己重写，就是有时候不需要让生成一大堆的方法...
Android通过ScaleGestureDetector实现图片缩放
true100的专栏
04-13 7650
之前有有开发过图片放大缩小功能，是用改写OnTouch（）方法来实现的，周末在家学习了下相关视屏， 发现通过ScaleGestureDetector来实现更加的方便，写篇学习日志！ /** * 自定义缩放ImageView * @description： * @author ldm * @date 2016-4-13 上午11:08:53 */ blic class ScaleImageV
Android 手势识别中的两个默认实现SimpleOnScaleGestureListener、SimpleOnGestureListener
打渔还是晒网 —— stone
08-11 1万+
//SimpleOnGestureListener implements OnGestureListener, OnDoubleTapListener class ZoomGesture extends GestureDetector.SimpleOnGestureListener {//单手指操作 @Override //双击 public boolean onDoubleTap
GestureDetector、手势、左右滑动控制图片大小
weixin_34033624的博客
05-04 131
GestureDetector手势，这个应用很广泛，也可以衍生初很多知识点，我从基础开始写起，原来一直想学一些高含量的技术，后来发现很多基础知识点都没完全理解，每当遇到不明白的小知识点的时候还要上网查，用过一次两次还记不住，好高骛远，踏踏实实把每个知识点的所有角角落落的零碎知识整理一下，基础扎实才会飞的更高；下面把GestureDetector的生命周期代码运...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值