Android 拖动、缩放不带矩阵的图像视图

我需要一个解决方案来实现拖拽和缩放，在触摸屏上路由ImageView而不使用矩阵。 我搜索了很多，但所有答案都是用矩阵完成的，因为屏幕矩阵中有多个对象不适合我，我希望在ImageView中拖动和缩放ImageView对象而不是矩阵，经过一些尝试后，我实现了一个类，该类可以拖动视图，但在缩放时会干扰，如果有人能帮助我，谢谢你，如果我的语言能力不好，如果我拼错了，请原谅

package com.example.painting1;

import android.graphics.PointF;
import android.util.FloatMath;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.widget.ImageView;

public class Drag implements OnTouchListener {

    ImageView img;

    // We can be in one of these 3 states
    private static final int NONE = 0;
    private static final int DRAG = 1;
    private static final int ZOOM = 2;

    private int mode = NONE;

    private PointF mid = new PointF();

    PointF DownPT = new PointF(); // Record Mouse Position When Pressed Down
    PointF StartPT = new PointF(); // Record Start Position of 'img'

    float oldDist = 1f;

    public Drag( ImageView img ) {
        // TODO Auto-generated constructor stub
        this.img = img;
        img.setOnTouchListener(this);
    }

        private float spacing(MotionEvent event) {
            float x = event.getX(0) - event.getX(1);
            float y = event.getY(0) - event.getY(1);
            return FloatMath.sqrt(x * x + y * y);
        }

        /**
         * Calculate the mid point of the first two fingers
         */
        private void midPoint(PointF point, MotionEvent event) {
            float x = event.getX(0) + event.getX(1);
            float y = event.getY(0) + event.getY(1);
            point.set(x / 2, y / 2);
        }

        @Override
            public boolean onTouch(View v, MotionEvent event)
            {
                int evid = event.getAction();
                int moid = MotionEvent.ACTION_MASK;

                switch (evid & moid)
                {
                    case MotionEvent.ACTION_MOVE :

                       if (mode == DRAG) {                      
                                PointF mv = new PointF( event.getX() - DownPT.x, event.getY() - DownPT.y);
                                img.setX((int)(StartPT.x+mv.x));
                                img.setY((int)(StartPT.y+mv.y));
                                StartPT = new PointF( img.getX(), img.getY() );
                        }

                         else if (mode == ZOOM) {
                                    float newDist = spacing(event);
                                    if (newDist > 10f) {
                                        //matrix.set(savedMatrix);
                                        float scale = (newDist / oldDist);
                                        //matrix.postScale(scale, scale, mid.x, mid.y);

                                        img.layout((int)scale, (int)scale, (int)mid.x, (int)mid.y);

                                        img.setScaleX(scale);
                                        img.setScaleY(scale);
                                    }
                         }

                        break;

                    case MotionEvent.ACTION_DOWN :

                        mode = DRAG;

                        DownPT.x = event.getX();
                        DownPT.y = event.getY();
                        StartPT = new PointF( img.getX(), img.getY() );
                        break;
                    case MotionEvent.ACTION_UP :
                        // Nothing have to do
                    case MotionEvent.ACTION_POINTER_UP :
                            mode = NONE;
                        break;

                    case MotionEvent.ACTION_POINTER_DOWN :

                        oldDist = spacing(event);
                        if (oldDist > 10f) {
                            //savedMatrix.set(matrix);
                            midPoint(mid, event);
                            mode = ZOOM;
                        }
                        break;
                    default :
                        break;
                }
                return true;
        }
}

试试这个代码

I have a solution for you,I wish it will work for you,

try to use TouchImageView instead of ImageView in Layout.because touchimageview have property that zooming in or out itself

https://github.com/MikeOrtiz/TouchImageView 

通过此链接，您将了解如何使用touchimageview

<com.luminous.pick.TouchImageView
                android:id="@+id/img2"
                android:layout_width="match_parent"
                android:layout_height="match_parent" />

Then After implement onDragListener of TouchImageView so you can get DRAG And Drop of Imageview easily...

@Override
public boolean onDrag(View v, DragEvent event) {

    switch (event.getAction()) {

        case DragEvent.ACTION_DROP:

            TouchImageView target = (TouchImageView) v;
            TouchImageView dragged = (TouchImageView) event.getLocalState();

            Drawable target_draw = target.getDrawable();
            Drawable dragged_draw = dragged.getDrawable();

            dragged.setImageDrawable(target_draw);
            target.setImageDrawable(dragged_draw);

   }
    return true;
}

然后在实现TouchImageView的onDragListener之后，您就可以轻松地拖放Imageview了。。。
@凌驾
公共布尔onDrag（视图v，DrageEvent事件）{
开关（event.getAction（））{
案例DrageEvent.ACTION_DROP：
TouchImageView目标=（TouchImageView）v；
TouchImageView=（TouchImageView）事件。getLocalState（）；
Drawable target_draw=target.getDrawable（）；
Drawable draw_draw=Drawed.getDrawable（）；
拖动。可设置图像绘制（目标绘制）；
target.setImageDrawable（拖放）；
}
返回true；
}

**以下是缩放、拖动、可触摸图像视图的完整源代码

在对图像执行拖动和缩放时，其工作平稳**

package com.admin.imagemovementzoom;

import android.annotation.SuppressLint;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.graphics.drawable.BitmapDrawable;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.FloatMath;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.animation.LinearInterpolator;
import android.widget.ImageView;
import android.widget.RelativeLayout;

import com.squareup.picasso.Picasso;


public class FullmageActivity extends AppCompatActivity implements View.OnTouchListener {

    private ImageView img_fullimage;
    private String picturePath;


    private static final String TAG = "Touch";
    // These matrices will be used to move and zoom image
    Matrix matrix = new Matrix();
    Matrix savedMatrix = new Matrix();

    // We can be in one of these 3 states
    static final int NONE = 0;
    static final int DRAG = 1;
    static final int ZOOM = 2;
    int mode = NONE;

    // Remember some things for zooming
    PointF start = new PointF();
    PointF mid = new PointF();
    float oldDist = 1f;

    @SuppressLint("ClickableViewAccessibility")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_fullmage);

        picturePath = getIntent().getStringExtra("image");

        FindId();

        Log.d("adaa", "file://" + picturePath);

        Picasso.get().load("file://" + picturePath).into(img_fullimage);

        img_fullimage.setOnTouchListener(this);
        img_fullimage.setScaleType(ImageView.ScaleType.MATRIX);

    }


    private void FindId() {
        img_fullimage = findViewById(R.id.img_full);
    }


    /**
     * Called when a touch event is dispatched to a view. This allows listeners to
     * get a chance to respond before the target view.
     *
     * @param v     The view the touch event has been dispatched to.
     * @param event The MotionEvent object containing full information about
     *              the event.
     * @return True if the listener has consumed the event, false otherwise.
     */
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        ImageView view = (ImageView) v;

        // Dump touch event to log
        dumpEvent(event);

        // Handle touch events here...
        switch (event.getAction() & MotionEvent.ACTION_MASK) {
            case MotionEvent.ACTION_DOWN:
                savedMatrix.set(matrix);
                start.set(event.getX(), event.getY());
                Log.d(TAG, "mode=DRAG");
                mode = DRAG;
                break;
            case MotionEvent.ACTION_POINTER_DOWN:
                oldDist = spacing(event);
                Log.d(TAG, "oldDist=" + oldDist);
                if (oldDist > 10f) {
                    savedMatrix.set(matrix);
                    midPoint(mid, event);
                    mode = ZOOM;
                    Log.d(TAG, "mode=ZOOM");
                }
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_POINTER_UP:
                mode = NONE;
                Log.d(TAG, "mode=NONE");
                break;
            case MotionEvent.ACTION_MOVE:
                if (mode == DRAG) {
                    // ...
                    matrix.set(savedMatrix);
                    matrix.postTranslate(event.getX() - start.x,
                            event.getY() - start.y);
                } else if (mode == ZOOM) {
                    float newDist = spacing(event);
                    Log.d(TAG, "newDist=" + newDist);
                    if (newDist > 10f) {
                        matrix.set(savedMatrix);
                        float scale = newDist / oldDist;
                        matrix.postScale(scale, scale, mid.x, mid.y);
                    }
                }
                break;
        }

        view.setImageMatrix(matrix);
        return true; // indicate event was handled
    }

    /**
     * Show an event in the LogCat view, for debugging
     */
    private void dumpEvent(MotionEvent event) {
        String names[] = {"DOWN", "UP", "MOVE", "CANCEL", "OUTSIDE",
                "POINTER_DOWN", "POINTER_UP", "7?", "8?", "9?"};
        StringBuilder sb = new StringBuilder();
        int action = event.getAction();
        int actionCode = action & MotionEvent.ACTION_MASK;
        sb.append("event ACTION_").append(names[actionCode]);
        if (actionCode == MotionEvent.ACTION_POINTER_DOWN
                || actionCode == MotionEvent.ACTION_POINTER_UP) {
            sb.append("(pid ").append(
                    action >> MotionEvent.ACTION_POINTER_ID_SHIFT);
            sb.append(")");
        }
        sb.append("[");
        for (int i = 0; i < event.getPointerCount(); i++) {
            sb.append("#").append(i);
            sb.append("(pid ").append(event.getPointerId(i));
            sb.append(")=").append((int) event.getX(i));
            sb.append(",").append((int) event.getY(i));
            if (i + 1 < event.getPointerCount())
                sb.append(";");
        }
        sb.append("]");
        Log.d(TAG, sb.toString());
    }

    /**
     * Determine the space between the first two fingers
     */
    private float spacing(MotionEvent event) {
        float x = event.getX(0) - event.getX(1);
        float y = event.getY(0) - event.getY(1);
        return (float) Math.sqrt(x * x + y * y);
    }

    /**
     * Calculate the mid point of the first two fingers
     */
    private void midPoint(PointF point, MotionEvent event) {
        float x = event.getX(0) + event.getX(1);
        float y = event.getY(0) + event.getY(1);
        point.set(x / 2, y / 2);
    }
}

package com.admin.imagemovementzoom；
导入android.annotation.SuppressLint；
导入android.graphics.Matrix；
导入android.graphics.PointF；
导入android.graphics.drawable.BitmapDrawable；
导入android.support.v7.app.AppActivity；
导入android.os.Bundle；
导入android.util.FloatMath；
导入android.util.Log；
导入android.view.MotionEvent；
导入android.view.view；
导入android.view.animation.LinearInterpolator；
导入android.widget.ImageView；
导入android.widget.RelativeLayout；
导入com.squareup.picasso.picasso；
公共类FullmageActivity扩展AppCompatActivity实现View.OnTouchListener{
私有图像查看img_fullimage；
私有字符串图片路径；
私有静态最终字符串TAG=“Touch”；
//这些矩阵将用于移动和缩放图像
矩阵=新矩阵（）；
矩阵savedMatrix=新矩阵（）；
//我们可能处于这三种状态之一
静态最终int NONE=0；
静态最终整数阻力=1；
静态最终整数缩放=2；
int模式=无；
//记住一些关于缩放的事情
PointF start=新的PointF（）；
PointF mid=新的PointF（）；
浮动oldDist=1f；
@SuppressLint（“ClickableViewAccessibility”）
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity\u fullmage）；
picturePath=getIntent（）.getStringExtra（“图像”）；
FindId（）；
Log.d（“adaa”，“文件：/”+picturePath）；
Picasso.get（）.load（“文件：/”+picturePath）.into（img_fullimage）；
img_fullimage.setOnTouchListener（这个）；
img_fullimage.setScaleType（ImageView.ScaleType.MATRIX）；
}
私人空间{
img_fullimage=findviewbyd（R.id.img_full）；
}
/**
*将触摸事件发送到视图时调用。这允许侦听器
*在目标视图之前获得响应的机会。
*
*@param v触摸事件已发送到的视图。
*@param event包含有关的完整信息的MotionEvent对象
*这件事。
*@如果侦听器已使用事件，则返回True，否则返回false。
*/
@凌驾
公共布尔onTouch（视图v，运动事件）{
ImageView视图=（ImageView）v；
//将触摸事件转储到日志
dumpEvent（事件）；
//在这里处理触摸事件。。。
开关（event.getAction（）&MotionEvent.ACTION\u掩码）{
case MotionEvent.ACTION\u DOWN：
savedMatrix.set（矩阵）；
set（event.getX（），event.getY（））；
Log.d（标记“mode=DRAG”）；
模式=拖动；
打破
case MotionEvent.ACTION\u指针\u向下：
oldDist=间距（事件）；
Log.d（标记“oldDist=“+oldDist”）；
如果（旧区>10f）{
savedMatrix.set（矩阵）；
中点（中点，事件）；
模式=缩放；
Log.d（标记“mode=ZOOM”）；
}
打破
case MotionEvent.ACTION\u UP：
case MotionEvent.ACTION\u指针\u向上：
模式=无；
Log.d（标记“mode=NONE”）；
打破
case MotionEvent.ACTION\u移动：
如果（模式==拖动）{
// ...
矩阵集（savedMatrix）；
postTranslate（event.getX（）-start.x，
event.getY（）-start.y）；
}else if（模式==缩放）{
float newDist=间距（事件）；
Log.d（标记“newDist=“+newDist”）；
如果（新距离>10f）{
矩阵集（savedMatrix）；
浮动比例=新距离/旧距离；
矩阵。后标度（标度、标度、中x、中y）；
}
}
打破
}
视图.setImageMatrix（矩阵）；
返回true；//指示事件已处理
}
/**
*在LogCat视图中显示事件以进行调试
*/
私有void转储事件（MotionEvent事件）{
字符串名称[]={“向下”、“向上”、“移动”、“取消”、“外部”，
“指针向下”、“指针向上”、“7？”、“8？”、“9？”；
StringBuilder sb=新的StringBuilder（）；
int action=event.getAction（）；
int actionCode=action&MotionEvent.action\u掩码；
附加（名称[动作代码]）；
如果（actionCode==MotionEvent.ACTION\u指针\u向下
||actionCode==M