android---图片获得与裁剪

图片从手机的图库中获取或者直接通过相机拍摄获得，获得图片后利用工具类对图片进行裁剪，为了防止内存溢出。

图片裁剪的工具类：CropImageActivity.java

package com.example.cropimage

import android.app.Activity;

import android.content.Intent;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.os.Bundle;

import android.os.Handler;

import android.os.Message;

import android.util.DisplayMetrics;

import android.util.Log;

import android.view.Gravity;

import android.view.View;

import android.view.View.OnClickListener;

import android.view.ViewGroup.LayoutParams;

import android.widget.Button;

import android.widget.FrameLayout;

import android.widget.ProgressBar;

import android.widget.Toast;

/**

* 裁剪界面

*

*/

public class CropImageActivity extends Activity implements OnClickListener{

private CropImageView mImageView;

private Bitmap mBitmap;

private CropImage mCrop;

private Button mSave;

private Button mCancel,rotateLeft,rotateRight;

private String mPath = "CropImageActivity";

private String TAG = "";

public int screenWidth = 0;

public int screenHeight = 0;

private ProgressBar mProgressBar;

public static final int SHOW_PROGRESS = 2000;

public static final int REMOVE_PROGRESS = 2001;

private Handler mHandler = new Handler(){

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case SHOW_PROGRESS:

mProgressBar.setVisibility(View.VISIBLE);

break;

case REMOVE_PROGRESS:

mHandler.removeMessages(SHOW_PROGRESS);

mProgressBar.setVisibility(View.INVISIBLE);

break;

}

}

};

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.gl_modify_avatar);

init();

}

@Override

protected void onStop(){

super.onStop();

if(mBitmap!=null){

mBitmap=null;

}

}

private void init()

{

getWindowWH();

mPath = getIntent().getStringExtra("path");

Log.i(TAG, "得到的图片的路径是 = " + mPath);

mImageView = (CropImageView) findViewById(R.id.gl_modify_avatar_image);

mSave = (Button) this.findViewById(R.id.gl_modify_avatar_save);

mCancel = (Button) this.findViewById(R.id.gl_modify_avatar_cancel);

rotateLeft = (Button) this.findViewById(R.id.gl_modify_avatar_rotate_left);

rotateRight = (Button) this.findViewById(R.id.gl_modify_avatar_rotate_right);

mSave.setOnClickListener(this);

mCancel.setOnClickListener(this);

rotateLeft.setOnClickListener(this);

rotateRight.setOnClickListener(this);

try{

mBitmap = createBitmap(mPath,screenWidth,screenHeight);

if(mBitmap==null){

Toast.makeText(CropImageActivity.this, CropImageActivity.this.getResources().getString(R.string.app_can_not_find_pic), 0).show();

finish();

}else{

resetImageView(mBitmap);

}

}catch (Exception e) {

Toast.makeText(CropImageActivity.this, CropImageActivity.this.getResources().getString(R.string.app_can_not_find_pic), 0).show();

finish();

}

addProgressbar();

}

/**

* 获取屏幕的高和宽

*/

private void getWindowWH(){

DisplayMetrics dm=new DisplayMetrics();

getWindowManager().getDefaultDisplay().getMetrics(dm);

screenWidth=dm.widthPixels;

screenHeight=dm.heightPixels;

}

private void resetImageView(Bitmap b){

mImageView.clear();

mImageView.setImageBitmap(b);

mImageView.setImageBitmapResetBase(b, true);

mCrop = new CropImage(this, mImageView,mHandler);

mCrop.crop(b);

}

@Override

public void onClick(View v)

{

switch (v.getId())

{

case R.id.gl_modify_avatar_cancel:

// mCrop.cropCancel();

finish();

break;

case R.id.gl_modify_avatar_save:

String path = mCrop.saveToLocal(mCrop.cropAndSave());

Log.i(TAG, "截取后图片的路径是 = " + path);

Intent intent = new Intent();

intent.putExtra("path", path);

setResult(RESULT_OK, intent);

finish();

break;

case R.id.gl_modify_avatar_rotate_left:

mCrop.startRotate(270.f);

break;

case R.id.gl_modify_avatar_rotate_right:

mCrop.startRotate(90.f);

break;

}

}

protected void addProgressbar() {

mProgressBar = new ProgressBar(this);

FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(

LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);

params.gravity = Gravity.CENTER;

addContentView(mProgressBar, params);

mProgressBar.setVisibility(View.INVISIBLE);

}

public Bitmap createBitmap(String path,int w,int h){

try{

BitmapFactory.Options opts = new BitmapFactory.Options();

opts.inJustDecodeBounds = true;

// 这里是整个方法的关键，inJustDecodeBounds设为true时将不为图片分配内存。

BitmapFactory.decodeFile(path, opts);

int srcWidth = opts.outWidth;// 获取图片的原始宽度

int srcHeight = opts.outHeight;// 获取图片原始高度

int destWidth = 0;

int destHeight = 0;

// 缩放的比例

double ratio = 0.0;

if (srcWidth < w || srcHeight < h) {

ratio = 0.0;

destWidth = srcWidth;

destHeight = srcHeight;

} else if (srcWidth > srcHeight) {// 按比例计算缩放后的图片大小，maxLength是长或宽允许的最大长度

ratio = (double) srcWidth / w;

destWidth = w;

destHeight = (int) (srcHeight / ratio);

} else {

ratio = (double) srcHeight / h;

destHeight = h;

destWidth = (int) (srcWidth / ratio);

}

BitmapFactory.Options newOpts = new BitmapFactory.Options();

// 缩放的比例，缩放是很难按准备的比例进行缩放的，目前我只发现只能通过inSampleSize来进行缩放，其值表明缩放的倍数，SDK中建议其值是2的指数值

newOpts.inSampleSize = (int) ratio + 1;

// inJustDecodeBounds设为false表示把图片读进内存中

newOpts.inJustDecodeBounds = false;

// 设置大小，这个一般是不准确的，是以inSampleSize的为准，但是如果不设置却不能缩放

newOpts.outHeight = destHeight;

newOpts.outWidth = destWidth;

// 获取缩放后图片

return BitmapFactory.decodeFile(path, newOpts);

} catch (Exception e) {

// TODO: handle exception

return null;

}

}

}

CropImage.java

package com.example.corpimage

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;

import cn.leature.istarbaby.R;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.graphics.Rect;
import android.graphics.RectF;
import android.media.FaceDetector;
import android.os.Environment;
import android.os.Handler;

/**
* 裁剪处理
*
*/
public class CropImage {

public static final File FILE_SDCARD = Environment
.getExternalStorageDirectory();

public static final File FILE_LOCAL = new File(FILE_SDCARD, "weixin");
private static final int CroppedImageWH = 400;

public boolean mWaitingToPick; // Whether we are wait the user to pick a
// face.
public boolean mSaving; // Whether the "save" button is already clicked.
public HighlightView mCrop;

private Context mContext;
private Handler mHandler;
private CropImageView mImageView;
private Bitmap mBitmap;

public CropImage(Context context, CropImageView imageView, Handler handler) {
mContext = context;
mImageView = imageView;
mImageView.setCropImage(this);
mHandler = handler;
}

/**
* 图片裁剪
*/
public void crop(Bitmap bm) {
mBitmap = bm;
startFaceDetection();
}

public void startRotate(float d) {
if (((Activity) mContext).isFinishing()) {
return;
}
final float degrees = d;
showProgressDialog(mContext.getResources().getString(R.string.gl_wait),
new Runnable() {
@Override
public void run() {
final CountDownLatch latch = new CountDownLatch(1);
mHandler.post(new Runnable() {
@Override
public void run() {
try {
Matrix m = new Matrix();
m.setRotate(degrees);
Bitmap tb = Bitmap.createBitmap(mBitmap, 0,
0, mBitmap.getWidth(),
mBitmap.getHeight(), m, false);
mBitmap = tb;
mImageView.resetView(tb);
if (mImageView.mHighlightViews.size() > 0) {
mCrop = mImageView.mHighlightViews
.get(0);
mCrop.setFocus(true);
}
} catch (Exception e) {
// TODO: handle exception
}
latch.countDown();
}
});
try {
latch.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// mRunFaceDetection.run();
}
}, mHandler);
}

private void startFaceDetection() {
if (((Activity) mContext).isFinishing()) {
return;
}
showProgressDialog(mContext.getResources().getString(R.string.gl_wait),
new Runnable() {
@Override
public void run() {
final CountDownLatch latch = new CountDownLatch(1);
final Bitmap b = mBitmap;
mHandler.post(new Runnable() {
@Override
public void run() {
if (b != mBitmap && b != null) {
mImageView.setImageBitmapResetBase(b, true);
mBitmap.recycle();
mBitmap = b;
}
if (mImageView.getScale() == 1.0f) {
mImageView.center(true, true);
}
latch.countDown();
}
});
try {
latch.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
mRunFaceDetection.run();
}
}, mHandler);
}

/**
* 裁剪并保存
*
* @return
*/
public Bitmap cropAndSave() {
final Bitmap bmp = onSaveClicked(mBitmap);
mImageView.mHighlightViews.clear();
return bmp;
}

/**
* 裁剪并保存
*
* @return
*/
public Bitmap cropAndSave(Bitmap bm) {
final Bitmap bmp = onSaveClicked(bm);
mImageView.mHighlightViews.clear();
return bmp;
}

/**
* 取消裁剪
*/
public void cropCancel() {
mImageView.mHighlightViews.clear();
mImageView.invalidate();
}

private Bitmap onSaveClicked(Bitmap bm) {
// CR: TODO!
// TODO this code needs to change to use the decode/crop/encode single
// step api so that we don't require that the whole (possibly large)
// bitmap doesn't have to be read into memory
if (mSaving)
return bm;

if (mCrop == null) {
return bm;
}

mSaving = true;

Rect r = mCrop.getCropRect();
// int width = r.width(); // CR: final == happy panda!
// int height = r.height();

// If we are circle cropping, we want alpha channel, which is the
// third param here.
// Bitmap croppedImage = Bitmap.createBitmap(width, height,
// Bitmap.Config.RGB_565);
// {
// Canvas canvas = new Canvas(croppedImage);
// Rect dstRect = new Rect(0, 0, width, height);
// canvas.drawBitmap(bm, r, dstRect, null);
// }

// Rect dr = mCrop.mDrawRect;
int width = CroppedImageWH; // dr.width(); // modify by yc
int height = CroppedImageWH; // dr.height();
Bitmap croppedImage = Bitmap.createBitmap(width, height,
Bitmap.Config.RGB_565);
{
Canvas canvas = new Canvas(croppedImage);
Rect dstRect = new Rect(0, 0, width, height);
canvas.drawBitmap(bm, r, dstRect, null);
}

return croppedImage;
}

public String saveToLocal(Bitmap bm) {
String path = FILE_LOCAL + "mm.jpg";
try {
FileOutputStream fos = new FileOutputStream(path);
bm.compress(CompressFormat.JPEG, 75, fos);
fos.flush();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
return null;
} catch (IOException e) {
e.printStackTrace();
return null;
}

return path;
}

private void showProgressDialog(String msg, Runnable job, Handler handler) {
// final ProgressDialog progress = ProgressDialog.show(mContext, null,
// msg);
// new Thread(new BackgroundJob(progress, job, handler)).start();
new Thread(new BackgroundJob(msg, job, handler)).start();
}

Runnable mRunFaceDetection = new Runnable() {
float mScale = 1F;
Matrix mImageMatrix;
FaceDetector.Face[] mFaces = new FaceDetector.Face[3];
int mNumFaces;

// For each face, we create a HightlightView for it.
private void handleFace(FaceDetector.Face f) {
PointF midPoint = new PointF();

int r = ((int) (f.eyesDistance() * mScale)) * 2;
f.getMidPoint(midPoint);
midPoint.x *= mScale;
midPoint.y *= mScale;

int midX = (int) midPoint.x;
int midY = (int) midPoint.y;

HighlightView hv = new HighlightView(mImageView);

int width = mBitmap.getWidth();
int height = mBitmap.getHeight();

Rect imageRect = new Rect(0, 0, width, height);

RectF faceRect = new RectF(midX, midY, midX, midY);
faceRect.inset(-r, -r);
if (faceRect.left < 0) {
faceRect.inset(-faceRect.left, -faceRect.left);
}

if (faceRect.top < 0) {
faceRect.inset(-faceRect.top, -faceRect.top);
}

if (faceRect.right > imageRect.right) {
faceRect.inset(faceRect.right - imageRect.right, faceRect.right
- imageRect.right);
}

if (faceRect.bottom > imageRect.bottom) {
faceRect.inset(faceRect.bottom - imageRect.bottom,
faceRect.bottom - imageRect.bottom);
}

hv.setup(mImageMatrix, imageRect, faceRect, false, true);

mImageView.add(hv);
}

// Create a default HightlightView if we found no face in the picture.
private void makeDefault() {
HighlightView hv = new HighlightView(mImageView);

int width = mBitmap.getWidth();
int height = mBitmap.getHeight();

Rect imageRect = new Rect(0, 0, width, height);

// CR: sentences!
// make the default size about 4/5 of the width or height
int cropWidth = Math.min(width, height) * 4 / 5;
int cropHeight = cropWidth;

int x = (width - cropWidth) / 2;
int y = (height - cropHeight) / 2;

RectF cropRect = new RectF(x, y, x + cropWidth, y + cropHeight);
hv.setup(mImageMatrix, imageRect, cropRect, false, true);
mImageView.add(hv);
}

// Scale the image down for faster face detection.
private Bitmap prepareBitmap() {
if (mBitmap == null) {
return null;
}

// 256 pixels wide is enough.
if (mBitmap.getWidth() > 256) {
mScale = 256.0F / mBitmap.getWidth(); // CR: F => f (or change
// all f to F).
}
Matrix matrix = new Matrix();
matrix.setScale(mScale, mScale);
Bitmap faceBitmap = Bitmap.createBitmap(mBitmap, 0, 0,
mBitmap.getWidth(), mBitmap.getHeight(), matrix, true);
return faceBitmap;
}

@Override
public void run() {
mImageMatrix = mImageView.getImageMatrix();
Bitmap faceBitmap = prepareBitmap();

mScale = 1.0F / mScale;
if (faceBitmap != null) {
FaceDetector detector = new FaceDetector(faceBitmap.getWidth(),
faceBitmap.getHeight(), mFaces.length);
mNumFaces = detector.findFaces(faceBitmap, mFaces);
}

if (faceBitmap != null && faceBitmap != mBitmap) {
faceBitmap.recycle();
}

mHandler.post(new Runnable() {
@Override
public void run() {
mWaitingToPick = mNumFaces > 1;
// if (mNumFaces > 0) {
// // for (int i = 0; i < mNumFaces; i++) {
// for (int i = 0; i < 1; i++) {
// handleFace(mFaces[i]);
// }
// } else {
makeDefault();
// }
mImageView.invalidate();
if (mImageView.mHighlightViews.size() > 0) {
mCrop = mImageView.mHighlightViews.get(0);
mCrop.setFocus(true);
}

if (mNumFaces > 1) {
// CR: no need for the variable t. just do
// Toast.makeText(...).show().
// Toast t = Toast.makeText(mContext,
// R.string.multiface_crop_help, Toast.LENGTH_SHORT);
// t.show();
}
}
});
}
};

class BackgroundJob implements Runnable {
// private ProgressDialog mProgress;
private String message;
private Runnable mJob;
private Handler mHandler;

// public BackgroundJob(ProgressDialog progress, Runnable job, Handler
// handler)
// {
// mProgress = progress;
// mJob = job;
// mHandler = handler;
// }
public BackgroundJob(String m, Runnable job, Handler handler) {
message = m;
mJob = job;
mHandler = handler;
// mProgress = new ProgressDialog(mContext);
// mProgress.setMessage(message);
// mProgress.show();
}

@Override
public void run() {
final CountDownLatch latch = new CountDownLatch(1);
mHandler.post(new Runnable() {
@Override
public void run() {
try {
mHandler.sendMessage(mHandler
.obtainMessage(CropImageActivity.SHOW_PROGRESS));
// if (mProgress != null && !mProgress.isShowing())
// {
// mProgress.show();
// }
} catch (Exception e) {
// TODO: handle exception
}

latch.countDown();
}
});
try {
latch.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
try {
mJob.run();
} finally {
mHandler.sendMessage(mHandler
.obtainMessage(CropImageActivity.REMOVE_PROGRESS));
// mHandler.post(new Runnable()
// {
// public void run()
// {
// if (mProgress != null && mProgress.isShowing())
// {
// mProgress.dismiss();
// mProgress = null;
// }
// }
// });
}
}
}
}

CropImageView.java

package cn.leature.istarbaby.info;

import java.util.ArrayList;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.RectF;
import android.util.AttributeSet;
import android.view.MotionEvent;

public class CropImageView extends ImageViewTouchBase {
public ArrayList<HighlightView> mHighlightViews = new ArrayList<HighlightView>();
HighlightView mMotionHighlightView = null;
float mLastX, mLastY;
int mMotionEdge;

private CropImage mCropImage;

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
if (mBitmapDisplayed.getBitmap() != null) {
for (HighlightView hv : mHighlightViews) {
hv.mMatrix.set(getImageMatrix());
hv.invalidate();
if (hv.mIsFocused) {
centerBasedOnHighlightView(hv);
}
}
}
}

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

@Override
protected void zoomTo(float scale, float centerX, float centerY) {
super.zoomTo(scale, centerX, centerY);
for (HighlightView hv : mHighlightViews) {
hv.mMatrix.set(getImageMatrix());
hv.invalidate();
}
}

@Override
protected void zoomIn() {
super.zoomIn();
for (HighlightView hv : mHighlightViews) {
hv.mMatrix.set(getImageMatrix());
hv.invalidate();
}
}

@Override
protected void zoomOut() {
super.zoomOut();
for (HighlightView hv : mHighlightViews) {
hv.mMatrix.set(getImageMatrix());
hv.invalidate();
}
}

@Override
protected void postTranslate(float deltaX, float deltaY) {
super.postTranslate(deltaX, deltaY);
for (int i = 0; i < mHighlightViews.size(); i++) {
HighlightView hv = mHighlightViews.get(i);
hv.mMatrix.postTranslate(deltaX, deltaY);
hv.invalidate();
}
}

// According to the event's position, change the focus to the first
// hitting cropping rectangle.
private void recomputeFocus(MotionEvent event) {
for (int i = 0; i < mHighlightViews.size(); i++) {
HighlightView hv = mHighlightViews.get(i);
hv.setFocus(false);
hv.invalidate();
}

for (int i = 0; i < mHighlightViews.size(); i++) {
HighlightView hv = mHighlightViews.get(i);
int edge = hv.getHit(event.getX(), event.getY());
if (edge != HighlightView.GROW_NONE) {
if (!hv.hasFocus()) {
hv.setFocus(true);
hv.invalidate();
}
break;
}
}
invalidate();
}

@Override
public boolean onTouchEvent(MotionEvent event) {
CropImage cropImage = mCropImage;
if (cropImage.mSaving) {
return false;
}

switch (event.getAction()) {
case MotionEvent.ACTION_DOWN: // CR: inline case blocks.
if (cropImage.mWaitingToPick) {
recomputeFocus(event);
} else {
for (int i = 0; i < mHighlightViews.size(); i++) { // CR:
// iterator
// for; if
// not, then
// i++ =>
// ++i.
HighlightView hv = mHighlightViews.get(i);
int edge = hv.getHit(event.getX(), event.getY());
if (edge != HighlightView.GROW_NONE) {
mMotionEdge = edge;
mMotionHighlightView = hv;
mLastX = event.getX();
mLastY = event.getY();
// CR: get rid of the extraneous parens below.
mMotionHighlightView.setMode((edge == HighlightView.MOVE) ? HighlightView.ModifyMode.Move
: HighlightView.ModifyMode.Grow);
break;
}
}
}
break;
// CR: vertical space before case blocks.
case MotionEvent.ACTION_UP:
if (cropImage.mWaitingToPick) {
for (int i = 0; i < mHighlightViews.size(); i++) {
HighlightView hv = mHighlightViews.get(i);
if (hv.hasFocus()) {
cropImage.mCrop = hv;
for (int j = 0; j < mHighlightViews.size(); j++) {
if (j == i) { // CR: if j != i do your shit; no need
// for continue.
continue;
}
mHighlightViews.get(j).setHidden(true);
}
centerBasedOnHighlightView(hv);
mCropImage.mWaitingToPick = false;
return true;
}
}
} else if (mMotionHighlightView != null) {
centerBasedOnHighlightView(mMotionHighlightView);
mMotionHighlightView.setMode(HighlightView.ModifyMode.None);
}
mMotionHighlightView = null;
break;
case MotionEvent.ACTION_MOVE:
if (cropImage.mWaitingToPick) {
recomputeFocus(event);
} else if (mMotionHighlightView != null) {
mMotionHighlightView.handleMotion(mMotionEdge, event.getX() - mLastX, event.getY() - mLastY);
mLastX = event.getX();
mLastY = event.getY();

if (true) {
// This section of code is optional. It has some user
// benefit in that moving the crop rectangle against
// the edge of the screen causes scrolling but it means
// that the crop rectangle is no longer fixed under
// the user's finger.
ensureVisible(mMotionHighlightView);
}
}
break;
}

switch (event.getAction()) {
case MotionEvent.ACTION_UP:
center(true, true);
break;
case MotionEvent.ACTION_MOVE:
// if we're not zoomed then there's no point in even allowing
// the user to move the image around. This call to center puts
// it back to the normalized location (with false meaning don't
// animate).
// if (getScale() == 1F) {
center(true, true);
// }
break;
}

return true;
}

// Pan the displayed image to make sure the cropping rectangle is visible.
private void ensureVisible(HighlightView hv) {
Rect r = hv.mDrawRect;

int panDeltaX1 = Math.max(0, getLeft() - r.left);
int panDeltaX2 = Math.min(0, getRight() - r.right);

int panDeltaY1 = Math.max(0, getTop() - r.top);
int panDeltaY2 = Math.min(0, getBottom() - r.bottom);

int panDeltaX = panDeltaX1 != 0 ? panDeltaX1 : panDeltaX2;
int panDeltaY = panDeltaY1 != 0 ? panDeltaY1 : panDeltaY2;

if (panDeltaX != 0 || panDeltaY != 0) {
panBy(panDeltaX, panDeltaY);
}
}

// If the cropping rectangle's size changed significantly, change the
// view's center and scale according to the cropping rectangle.
//hv.mDrawRect.width<0.54*thisWidth||width>0.66*thisWidth,need to zoom
private void centerBasedOnHighlightView(HighlightView hv) {
Rect drawRect = hv.mDrawRect;

float width = drawRect.width();
float height = drawRect.height();

float thisWidth = getWidth();
float thisHeight = getHeight();

float z1 = thisWidth / width * .6F;
float z2 = thisHeight / height * .6F;

float zoom = Math.min(z1, z2);
zoom = zoom * this.getScale();
zoom = Math.max(1F, zoom);//assure getScale()>1

if ((Math.abs(zoom - getScale()) / zoom) > 0.1) {
float[] coordinates = new float[] { hv.mCropRect.centerX(), hv.mCropRect.centerY() };
getImageMatrix().mapPoints(coordinates);
zoomTo(zoom, coordinates[0], coordinates[1], 300F); // CR: 300.0f.
}

ensureVisible(hv);
}

@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
for (int i = 0; i < mHighlightViews.size(); i++) {
mHighlightViews.get(i).draw(canvas);
}
}

public void add(HighlightView hv) {
mHighlightViews.clear();
mHighlightViews.add(hv);
invalidate();
}

public void setCropImage(CropImage cropImage)
{
mCropImage = cropImage;
}
public void resetView(Bitmap b){
setImageBitmap(b);
setImageBitmapResetBase(b, true);
setImageMatrix(getImageViewMatrix());
int width = mBitmapDisplayed.getWidth();
int height = mBitmapDisplayed.getHeight();
Rect imageRect = new Rect(0, 0, width, height);
int cropWidth = Math.min(width, height) * 4 / 5;
int cropHeight = cropWidth;
int x = (width - cropWidth) / 2;
int y = (height - cropHeight) / 2;
RectF cropRect = new RectF(x, y, x + cropWidth, y + cropHeight);
HighlightView hv = new HighlightView(this);
hv.setup(getImageViewMatrix(), imageRect, cropRect, false, true);
hv.setFocus(true);
add(hv);
centerBasedOnHighlightView(hv);
hv.setMode(HighlightView.ModifyMode.None);
center(true, true);
invalidate();
}

}

ImageViewTouchBase.java

package cn.leature.istarbaby.info;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.os.Handler;
import android.util.AttributeSet;
import android.view.KeyEvent;
import android.widget.ImageView;

public abstract class ImageViewTouchBase extends ImageView {

@SuppressWarnings("unused")
private static final String TAG = "ImageViewTouchBase";

// This is the base transformation which is used to show the image
// initially. The current computation for this shows the image in
// it's entirety, letterboxing as needed. One could choose to
// show the image as cropped instead.
//
// This matrix is recomputed when we go from the thumbnail image to
// the full size image.
protected Matrix mBaseMatrix = new Matrix();

// This is the supplementary transformation which reflects what
// the user has done in terms of zooming and panning.
//
// This matrix remains the same when we go from the thumbnail image
// to the full size image.
protected Matrix mSuppMatrix = new Matrix();

// This is the final matrix which is computed as the concatentation
// of the base matrix and the supplementary matrix.
private final Matrix mDisplayMatrix = new Matrix();

// Temporary buffer used for getting the values out of a matrix.
private final float[] mMatrixValues = new float[9];

// The current bitmap being displayed.
final public RotateBitmap mBitmapDisplayed = new RotateBitmap(null);

int mThisWidth = -1, mThisHeight = -1;

float mMaxZoom;

/**
* 高亮状态
*/
public static final int STATE_HIGHLIGHT = 0x0;

/**
* 涂鸦状态
*/
public static final int STATE_DOODLE = STATE_HIGHLIGHT + 1;

/**
* 没有任何操作
*/
public static final int STATE_NONE = STATE_HIGHLIGHT + 2;
protected int mState = STATE_HIGHLIGHT;

// ImageViewTouchBase will pass a Bitmap to the Recycler if it has finished
// its use of that Bitmap.
public interface Recycler {
public void recycle(Bitmap b);
}

public void setRecycler(Recycler r) {
mRecycler = r;
}

private Recycler mRecycler;

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
mThisWidth = right - left;
mThisHeight = bottom - top;
Runnable r = mOnLayoutRunnable;
if (r != null) {
mOnLayoutRunnable = null;
r.run();
}
if (mBitmapDisplayed.getBitmap() != null) {
getProperBaseMatrix(mBitmapDisplayed, mBaseMatrix);
setImageMatrix(getImageViewMatrix());
}
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK && getScale() > 1.0f) {
// If we're zoomed in, pressing Back jumps out to show the entire
// image, otherwise Back returns the user to the gallery.
zoomTo(1.0f);
return true;
}
return super.onKeyDown(keyCode, event);
}

protected Handler mHandler = new Handler();

protected int mLastXTouchPos;
protected int mLastYTouchPos;

@Override
public void setImageBitmap(Bitmap bitmap) {
setImageBitmap(bitmap, 0);
}

private void setImageBitmap(Bitmap bitmap, int rotation) {
super.setImageBitmap(bitmap);
Drawable d = getDrawable();
if (d != null) {
d.setDither(true);
}

Bitmap old = mBitmapDisplayed.getBitmap();
mBitmapDisplayed.setBitmap(bitmap);
mBitmapDisplayed.setRotation(rotation);

if (old != null && old != bitmap && mRecycler != null) {
mRecycler.recycle(old);
}
}

public void clear() {
setImageBitmapResetBase(null, true);
}

private Runnable mOnLayoutRunnable = null;

// This function changes bitmap, reset base matrix according to the size
// of the bitmap, and optionally reset the supplementary matrix.
public void setImageBitmapResetBase(final Bitmap bitmap, final boolean resetSupp) {
setImageRotateBitmapResetBase(new RotateBitmap(bitmap), resetSupp);
}
public void setImageRotateBitmapResetBase(final RotateBitmap bitmap, final boolean resetSupp) {
final int viewWidth = getWidth();

if (viewWidth <= 0) {
mOnLayoutRunnable = new Runnable() {
@Override
public void run() {
setImageRotateBitmapResetBase(bitmap, resetSupp);
}
};
return;
}

if (bitmap.getBitmap() != null) {
getProperBaseMatrix(bitmap, mBaseMatrix);
setImageBitmap(bitmap.getBitmap(), bitmap.getRotation());
} else {
mBaseMatrix.reset();
setImageBitmap(null);
}

if (resetSupp) {
mSuppMatrix.reset();
}
setImageMatrix(getImageViewMatrix());
mMaxZoom = maxZoom();
}

// Center as much as possible in one or both axis. Centering is
// defined as follows: if the image is scaled down below the
// view's dimensions then center it (literally). If the image
// is scaled larger than the view and is translated out of view
// then translate it back into view (i.e. eliminate black bars).
public void center(boolean horizontal, boolean vertical) {
if (mBitmapDisplayed.getBitmap() == null) {
return;
}

Matrix m = getImageViewMatrix();

RectF rect = new RectF(0, 0, mBitmapDisplayed.getBitmap().getWidth(), mBitmapDisplayed.getBitmap().getHeight());

m.mapRect(rect);

float height = rect.height();
float width = rect.width();

float deltaX = 0, deltaY = 0;

if (vertical) {
int viewHeight = getHeight();
if (height < viewHeight) {
deltaY = (viewHeight - height) / 2 - rect.top;
} else if (rect.top > 0) {
deltaY = -rect.top;
} else if (rect.bottom < viewHeight) {
deltaY = getHeight() - rect.bottom;
}
}

if (horizontal) {
int viewWidth = getWidth();
if (width < viewWidth) {
deltaX = (viewWidth - width) / 2 - rect.left;
} else if (rect.left > 0) {
deltaX = -rect.left;
} else if (rect.right < viewWidth) {
deltaX = viewWidth - rect.right;
}
}

postTranslate(deltaX, deltaY);
setImageMatrix(getImageViewMatrix());
}

public ImageViewTouchBase(Context context) {
super(context);
init();
}

public ImageViewTouchBase(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}

private void init() {
setScaleType(ImageView.ScaleType.MATRIX);
}

protected float getValue(Matrix matrix, int whichValue) {
matrix.getValues(mMatrixValues);
return mMatrixValues[whichValue];
}

// Get the scale factor out of the matrix.
protected float getScale(Matrix matrix) {
return getValue(matrix, Matrix.MSCALE_X);
}

public float getScale() {
return getScale(mSuppMatrix);
}

// Setup the base matrix so that the image is centered and scaled properly.
private void getProperBaseMatrix(RotateBitmap bitmap, Matrix matrix) {
float viewWidth = getWidth();
float viewHeight = getHeight();

float w = bitmap.getWidth();
float h = bitmap.getHeight();
matrix.reset();

// We limit up-scaling to 2x otherwise the result may look bad if it's
// a small icon.
float widthScale = Math.min(viewWidth / w, 2.0f);
float heightScale = Math.min(viewHeight / h, 2.0f);
float scale = Math.min(widthScale, heightScale);

matrix.postConcat(bitmap.getRotateMatrix());
matrix.postScale(scale, scale);

matrix.postTranslate((viewWidth - w * scale) / 2F, (viewHeight - h * scale) / 2F);
}

// Combine the base matrix and the supp matrix to make the final matrix.
protected Matrix getImageViewMatrix() {
// The final matrix is computed as the concatentation of the base matrix
// and the supplementary matrix.
mDisplayMatrix.set(mBaseMatrix);
mDisplayMatrix.postConcat(mSuppMatrix);
return mDisplayMatrix;
}

static final float SCALE_RATE = 1.25F;

// Sets the maximum zoom, which is a scale relative to the base matrix. It
// is calculated to show the image at 400% zoom regardless of screen or
// image orientation. If in the future we decode the full 3 megapixel image,
// rather than the current 1024x768, this should be changed down to 200%.
protected float maxZoom() {
if (mBitmapDisplayed.getBitmap() == null) {
return 1F;
}

float fw = (float) mBitmapDisplayed.getWidth() / (float) mThisWidth;
float fh = (float) mBitmapDisplayed.getHeight() / (float) mThisHeight;
float max = Math.max(fw, fh) * 4;
max = (max<1.0f)?1.0f:max;
return max;
}

protected void zoomTo(float scale, float centerX, float centerY) {
if (scale > mMaxZoom) {
scale = mMaxZoom;
}

float oldScale = getScale();
float deltaScale = scale / oldScale;

mSuppMatrix.postScale(deltaScale, deltaScale, centerX, centerY);
setImageMatrix(getImageViewMatrix());
center(true, true);
}

protected void zoomTo(final float scale, final float centerX, final float centerY, final float durationMs) {
final float incrementPerMs = (scale - getScale()) / durationMs;
final float oldScale = getScale();
final long startTime = System.currentTimeMillis();

mHandler.post(new Runnable() {
@Override
public void run() {
long now = System.currentTimeMillis();
float currentMs = Math.min(durationMs, now - startTime);
float target = oldScale + (incrementPerMs * currentMs);
zoomTo(target, centerX, centerY);

if (currentMs < durationMs) {
mHandler.post(this);
}
}
});
}

protected void zoomTo(float scale) {
float cx = getWidth() / 2F;
float cy = getHeight() / 2F;

zoomTo(scale, cx, cy);
}

protected void zoomIn() {
zoomIn(SCALE_RATE);
}

protected void zoomOut() {
zoomOut(SCALE_RATE);
}

protected void zoomIn(float rate) {
if (getScale() >= mMaxZoom) {
return; // Don't let the user zoom into the molecular level.
}
if (mBitmapDisplayed.getBitmap() == null) {
return;
}

float cx = getWidth() / 2F;
float cy = getHeight() / 2F;

mSuppMatrix.postScale(rate, rate, cx, cy);
setImageMatrix(getImageViewMatrix());
}

protected void zoomOut(float rate) {
if (mBitmapDisplayed.getBitmap() == null) {
return;
}

float cx = getWidth() / 2F;
float cy = getHeight() / 2F;

// Zoom out to at most 1x.
Matrix tmp = new Matrix(mSuppMatrix);
tmp.postScale(1F / rate, 1F / rate, cx, cy);

if (getScale(tmp) < 1F) {
mSuppMatrix.setScale(1F, 1F, cx, cy);
} else {
mSuppMatrix.postScale(1F / rate, 1F / rate, cx, cy);
}
setImageMatrix(getImageViewMatrix());
center(true, true);
}

protected void postTranslate(float dx, float dy) {
mSuppMatrix.postTranslate(dx, dy);
}

protected void panBy(float dx, float dy) {
postTranslate(dx, dy);
setImageMatrix(getImageViewMatrix());
}

}

从相册中获取图片：

intent.setAction(Intent.ACTION_PICK);
intent.setType("image/*");
startActivityForResult(intent, FLAG_CHOOSE_IMG);

通过相机获取图片：

String status = Environment.getExternalStorageState();
if (status.equals(Environment.MEDIA_MOUNTED)) {
try {
localTempImageFileName = "";
localTempImageFileName = String.valueOf((new Date())
.getTime()) + ".png";
File filePath = FILE_PIC_SCREENSHOT;
if (!filePath.exists()) {
filePath.mkdirs();
}
Intent intent1 = new Intent(
android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
File f = new File(filePath, localTempImageFileName);
// localTempImgDir和localTempImageFileName是自己定义的名字
Uri u = Uri.fromFile(f);
intent1.putExtra(ImageColumns.ORIENTATION, 0);
intent1.putExtra(MediaStore.EXTRA_OUTPUT, u);
startActivityForResult(intent1, FLAG_CHOOSE_PHONE);
} catch (ActivityNotFoundException e) {
//
}
}

在Activity回调中：对不同来源的图片进行处理，先交给裁剪工具，裁剪完后再将图片拿来使用

if (requestCode == FLAG_CHOOSE_IMG && resultCode == RESULT_OK) {
if (data != null) {
Uri uri = data.getData();
if (!TextUtils.isEmpty(uri.getAuthority())) {
Cursor cursor = getContentResolver().query(uri,
new String[] { MediaColumns.DATA }, null, null,
null);
if (null == cursor) {
return;
}
cursor.moveToFirst();
String path = cursor.getString(cursor
.getColumnIndex(MediaColumns.DATA));
cursor.close();
cursor.close();
Intent intent = new Intent(this, CropImageActivity.class);
intent.putExtra("path", path);
startActivityForResult(intent, FLAG_MODIFY_FINISH);
} else {
Intent intent = new Intent(this, CropImageActivity.class);
intent.putExtra("path", uri.getPath());
startActivityForResult(intent, FLAG_MODIFY_FINISH);
}
}
} else if (requestCode == FLAG_CHOOSE_PHONE && resultCode == RESULT_OK) {
File f = new File(FILE_PIC_SCREENSHOT, localTempImageFileName);
Intent intent = new Intent(this, CropImageActivity.class);
intent.putExtra("path", f.getAbsolutePath());
startActivityForResult(intent, FLAG_MODIFY_FINISH);
} else if (requestCode == FLAG_MODIFY_FINISH && resultCode == RESULT_OK) {
if (data != null) {
final String path = data.getStringExtra("path");
Bitmap bm = BitmapFactory.decodeFile(path);
// 裁剪成正方形图片
mIconBitmap = ResizeImage.resizeBitmapWithRadio(bm, 1, 1);

mChild_Icon.setImageBitmap(mIconBitmap);
uploadIconBitmap();
}
}

备注：private static final int FLAG_CHOOSE_IMG = 5;

private static final int FLAG_CHOOSE_PHONE = 6;

private static final int FLAG_MODIFY_FINISH = 7;

public static final String IMAGE_PATH = "My_weixin";

public static final File FILE_SDCARD = Environment

.getExternalStorageDirectory();

public static final File FILE_LOCAL = new File(FILE_SDCARD, IMAGE_PATH);

public static final File FILE_PIC_SCREENSHOT = new File(FILE_LOCAL,

"images/screenshots");

private static String localTempImageFileName = "";