3

我发现了这个 如何在android中为图像启用(两指)放大/缩小功能

在日志中我看到它正在工作但图像没有改变,我做错了什么?

这是我的xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".ViewImage" >

    <ImageView
        android:id="@+id/myimage"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_alignParentLeft="true"
        android:layout_alignParentRight="true"
        android:layout_alignParentTop="true"
        android:layout_alignParentBottom="true" />

</RelativeLayout>

这是我的代码

public class ViewImage extends Activity implements OnTouchListener {

    private SQLiteDatabase qdb;
    ImageView myimage;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_view_image);
        myimage = (ImageView) findViewById(R.id.myimage);
        DB db = new DB(this);
        qdb = db.getReadableDatabase();
        Bundle b = getIntent().getExtras();
        int img_id = b.getInt("img_id");
        Cursor c = qdb.rawQuery("select name,  comment from photos where _id="+img_id+"", null);
        if(c.moveToFirst()){
            String img_name = c.getString(c.getColumnIndex("name"));
            String img_comment = c.getString(c.getColumnIndex("comment"));
            File directory = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "NNCam");
            String resPath = directory.getPath();
            Bitmap imgComment = getPoster(img_comment, resPath+img_name);
            saveImage(resPath+"/Temp", img_name, imgComment);
            myimage.setImageBitmap(BitmapFactory.decodeFile(resPath+img_name));
            myimage.setOnTouchListener(this);
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.view_image, menu);
        return true;
    }


    public void saveImage(String path, String imgname, Bitmap image){
        try{
            FileOutputStream fos = new FileOutputStream(path+imgname);

        BufferedOutputStream  stream = new BufferedOutputStream(fos);

        image.compress(CompressFormat.JPEG, 100, stream);

        stream.flush();
        stream.close();
        }
        catch(FileNotFoundException e){

        }
        catch(IOException e){

        }
    }

    private static Bitmap getPoster(String yazi, String resPath) {
        Bitmap background = BitmapFactory.decodeFile(resPath).copy(Bitmap.Config.ARGB_8888, true);;
        Canvas canvas = new Canvas(background);
        Paint paint = new Paint();
        paint.setAntiAlias(true);
        paint.setColor(Color.WHITE);
        paint.setStyle(Style.FILL);
        paint.setShadowLayer(2.0f, 1.0f, 1.0f, Color.BLACK);
        float fontSize = background.getHeight()/30; //You'll have to define a way to find a size that fits, or just use a constant size.

        paint.setTextSize(fontSize);
        int y = (int) background.getHeight() - 100;
        for(String line: yazi.split("\n")){
              canvas.drawText(line, ((background.getWidth() - paint.measureText(line)) / 2), y, paint);
              y-=paint.ascent()+paint.descent()-5;
        } 
        return background;
    }


  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;
  static final int DRAW =3;
  int mode = NONE;

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

  // Limit zoomable/pannable image
  private float[] matrixValues = new float[9];
  private float maxZoom;
  private float minZoom;
  private float height;
  private float width;
  private RectF viewRect;
  /////////************ touch events functions **************////////////////////
  @Override
  public void onWindowFocusChanged(boolean hasFocus) {
      super.onWindowFocusChanged(hasFocus);
      if(hasFocus){  init();   }
  }
  private void init() {
      maxZoom = 4;
      minZoom = 0.25f;
      height = myimage.getDrawable().getIntrinsicHeight()+20;
      width = myimage.getDrawable().getIntrinsicWidth()+20;
      viewRect = new RectF(0, 0, myimage.getWidth()+20, myimage.getHeight()+20);
  }

    /////////************touch events for image Moving, panning and zooming   ***********///
  public boolean onTouch(View v, MotionEvent event) {

      // 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 == DRAW){ onTouchEvent(event);}
          if (mode == DRAG) {
                  ///code for draging..        
          } 
       else if (mode == ZOOM) {
           float newDist = spacing(event);
           Log.d(TAG, "newDist=" + newDist);
           if (newDist > 10f) {
               matrix.set(savedMatrix);
               float scale = newDist / oldDist;
               matrix.getValues(matrixValues);
               float currentScale = matrixValues[Matrix.MSCALE_X];
               // limit zoom
               if (scale * currentScale > maxZoom) {
                   scale = maxZoom / currentScale; 
                  }else if(scale * currentScale < minZoom){
                      scale = minZoom / currentScale; 
                   }
               matrix.postScale(scale, scale, mid.x, mid.y);
              }
       }
       break;
      }
      myimage.setImageMatrix(matrix);
      return true; // indicate event was handled
  }

  //*******************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 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);
  }
  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());
   }

}
4

1 回答 1

5

尝试使用这个类你会实现它

在您的项目中创建一个类

import android.content.Context;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;
import android.widget.ImageView;

public class TouchImageView extends ImageView {
Matrix 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 last = new PointF();
PointF start = new PointF();
float minScale = 1f;
float maxScale = 3f;
float[] m;

int viewWidth, viewHeight;
static final int CLICK = 3;
float saveScale = 1f;
protected float origWidth, origHeight;
int oldMeasuredWidth, oldMeasuredHeight;

ScaleGestureDetector mScaleDetector;

Context context;

public TouchImageView(Context context) {
    super(context);
    sharedConstructing(context);
}

public TouchImageView(Context context, AttributeSet attrs) {
    super(context, attrs);
    sharedConstructing(context);
}

private void sharedConstructing(Context context) {
    super.setClickable(true);
    this.context = context;
    mScaleDetector = new ScaleGestureDetector(context, new ScaleListener());
    matrix = new Matrix();
    m = new float[9];
    setImageMatrix(matrix);
    setScaleType(ScaleType.MATRIX);

    setOnTouchListener(new OnTouchListener() {

        @Override
        public boolean onTouch(View v, MotionEvent event) {
            mScaleDetector.onTouchEvent(event);
            PointF curr = new PointF(event.getX(), event.getY());

            switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                last.set(curr);
                start.set(last);
                mode = DRAG;
                break;

            case MotionEvent.ACTION_MOVE:
                if (mode == DRAG) {
                    float deltaX = curr.x - last.x;
                    float deltaY = curr.y - last.y;
                    float fixTransX = getFixDragTrans(deltaX, viewWidth,
                            origWidth * saveScale);
                    float fixTransY = getFixDragTrans(deltaY, viewHeight,
                            origHeight * saveScale);
                    matrix.postTranslate(fixTransX, fixTransY);
                    fixTrans();
                    last.set(curr.x, curr.y);
                }
                break;

            case MotionEvent.ACTION_UP:
                mode = NONE;
                int xDiff = (int) Math.abs(curr.x - start.x);
                int yDiff = (int) Math.abs(curr.y - start.y);
                if (xDiff < CLICK && yDiff < CLICK)
                    performClick();
                break;

            case MotionEvent.ACTION_POINTER_UP:
                mode = NONE;
                break;
            }

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

    });
}

public void setMaxZoom(float x) {
    maxScale = x;
}

private class ScaleListener extends
        ScaleGestureDetector.SimpleOnScaleGestureListener {
    @Override
    public boolean onScaleBegin(ScaleGestureDetector detector) {
        mode = ZOOM;
        return true;
    }

    @Override
    public boolean onScale(ScaleGestureDetector detector) {
        float mScaleFactor = detector.getScaleFactor();
        float origScale = saveScale;
        saveScale *= mScaleFactor;
        if (saveScale > maxScale) {
            saveScale = maxScale;
            mScaleFactor = maxScale / origScale;
        } else if (saveScale < minScale) {
            saveScale = minScale;
            mScaleFactor = minScale / origScale;
        }

        if (origWidth * saveScale <= viewWidth
                || origHeight * saveScale <= viewHeight)
            matrix.postScale(mScaleFactor, mScaleFactor, viewWidth / 2,
                    viewHeight / 2);
        else
            matrix.postScale(mScaleFactor, mScaleFactor,
                    detector.getFocusX(), detector.getFocusY());

        fixTrans();
        return true;
    }
}

void fixTrans() {
    matrix.getValues(m);
    float transX = m[Matrix.MTRANS_X];
    float transY = m[Matrix.MTRANS_Y];

    float fixTransX = getFixTrans(transX, viewWidth, origWidth * saveScale);
    float fixTransY = getFixTrans(transY, viewHeight, origHeight
            * saveScale);

    if (fixTransX != 0 || fixTransY != 0)
        matrix.postTranslate(fixTransX, fixTransY);
}

float getFixTrans(float trans, float viewSize, float contentSize) {
    float minTrans, maxTrans;

    if (contentSize <= viewSize) {
        minTrans = 0;
        maxTrans = viewSize - contentSize;
    } else {
        minTrans = viewSize - contentSize;
        maxTrans = 0;
    }

    if (trans < minTrans)
        return -trans + minTrans;
    if (trans > maxTrans)
        return -trans + maxTrans;
    return 0;
}

float getFixDragTrans(float delta, float viewSize, float contentSize) {
    if (contentSize <= viewSize) {
        return 0;
    }
    return delta;
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    viewWidth = MeasureSpec.getSize(widthMeasureSpec);
    viewHeight = MeasureSpec.getSize(heightMeasureSpec);

    //
    // Rescales image on rotation
    //
    if (oldMeasuredHeight == viewWidth && oldMeasuredHeight == viewHeight
            || viewWidth == 0 || viewHeight == 0)
        return;
    oldMeasuredHeight = viewHeight;
    oldMeasuredWidth = viewWidth;

    if (saveScale == 1) {
        // Fit to screen.
        float scale;

        Drawable drawable = getDrawable();
        if (drawable == null || drawable.getIntrinsicWidth() == 0
                || drawable.getIntrinsicHeight() == 0)
            return;
        int bmWidth = drawable.getIntrinsicWidth();
        int bmHeight = drawable.getIntrinsicHeight();

        Log.d("bmSize", "bmWidth: " + bmWidth + " bmHeight : " + bmHeight);

        float scaleX = (float) viewWidth / (float) bmWidth;
        float scaleY = (float) viewHeight / (float) bmHeight;
        scale = Math.min(scaleX, scaleY);
        matrix.setScale(scale, scale);

        // Center the image
        float redundantYSpace = (float) viewHeight
                - (scale * (float) bmHeight);
        float redundantXSpace = (float) viewWidth
                - (scale * (float) bmWidth);
        redundantYSpace /= (float) 2;
        redundantXSpace /= (float) 2;

        matrix.postTranslate(redundantXSpace, redundantYSpace);

        origWidth = viewWidth - 2 * redundantXSpace;
        origHeight = viewHeight - 2 * redundantYSpace;
        setImageMatrix(matrix);
    }
    fixTrans();
}
}

在编码中ImageView myimage;应该声明为类似TouchImageView myimage在 xml 你应该直接链接到这个应该转换为TouchImageView<ImageView<package.TouchImageView

于 2013-08-06T12:09:33.337 回答