仿微信头像图片裁剪并压缩到100K以下到本地
逻辑：1、打开本地相机-并传入path路径
2、在onActivityResult中，判断File(path)是否为空,不为空则跳转到下个界面
PS：这里为什么要用path而不用onActivity返回的bitmap对象呢。 因为返回的bitmap对象是没有path路径的图片清晰
3、利用ClipImageLayout来对图片进行裁剪--并获取到裁剪完毕之后的图片
4、对图片进行质量压缩，并保存到本地
DEMO下载地址：http://download.csdn.net/detail/q908555281/9311177
2、在onActivityResult中，判断File(path)是否为空,不为空则跳转到下个界面
PS：这里为什么要用path而不用onActivity返回的bitmap对象呢。 因为返回的bitmap对象是没有path路径的图片清晰
3、利用ClipImageLayout来对图片进行裁剪--并获取到裁剪完毕之后的图片
4、对图片进行质量压缩，并保存到本地
PS:第四部的时候，一定要压缩之后们通过流的方式保存到本地,不要在调用BitmapFactory.decodeStream方法，否则又会回到200K
import java.io.File;
import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class MainActivity extends Activity {
private File file; // 要保存的文件sss
private Button btnCamera;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout. activity_main);
btnCamera = (Button) findViewById(R.id. btn_camera);
btnCamera.setOnClickListener( new OnClickListener() {
@Override
public void onClick(View v) {
file = new File(FileUtils.getImgStorageDirectory() + "/aa.jpg");
Intent intent = new Intent();
intent.setAction( "android.media.action.IMAGE_CAPTURE");
Uri uri = Uri. fromFile(file);
intent.putExtra(MediaStore. EXTRA_OUTPUT, uri);
startActivityForResult(intent, 100);
}
});
}
@Override
protected void onActivityResult( int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == 100 && file.exists() && file.length() > 0) {
// 这里吧文件的路径传入到下一个界面，就是裁剪的界面
Intent intent = new Intent(MainActivity. this, CropActivity.class);
intent.putExtra( "path", file.getPath());
startActivity(intent);
}
}
}
第二个界面：裁剪的界面：
import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import com.example.ima.view.ClipImageLayout;
public class CropActivity extends Activity implements OnClickListener {
private Button btn;
private ClipImageLayout mClipImageLayout;
private String path;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout. activity_crop);
path = getIntent().getStringExtra( "path");
btn = (Button) findViewById(R.id. crop_button);
btn.setOnClickListener(CropActivity. this);
mClipImageLayout = (ClipImageLayout) findViewById(R.id.clipImageLayout );
// 有的系统返回的图片是旋转了，有的没有旋转，所以处理
int degreee = ImageUtil. readPictureDegree(path);
Bitmap bitmap = ImageUtil. getSmallBitmap(path);
if (bitmap != null) {
if (degreee == 0) {
mClipImageLayout.setImageBitmap(bitmap);
} else {
mClipImageLayout.setImageBitmap(ImageUtil. rotaingBitmap(degreee, bitmap));
}
}
}
@Override
public void onClick(View v) {
//得到裁剪的图片
Bitmap bitmap = mClipImageLayout.clip();
String imageName = String.valueOf(System.currentTimeMillis());
//这里把裁剪过后的图片进行质量压缩，并且保存到本地
ImageUtil. compressAndSave(bitmap, imageName);
Intent intent = new Intent(CropActivity. this, ShowActivity.class);
intent.putExtra( "imageName", imageName);
startActivity(intent);
}
}
这个类的布局文件：
<LinearLayout xmlns:android= "http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width= "fill_parent"
android:layout_height= "fill_parent"
android:background="#000000"
android:orientation="vertical" >
<Button
android:id= "@+id/crop_button"
android:layout_width= "match_parent"
android:layout_height= "wrap_content"
android:layout_gravity= "center"
android:layout_margin= "16dp"
android:text="CROP" />
<com.example.ima.view.ClipImageLayout
android:id= "@+id/clipImageLayout"
android:layout_width= "match_parent"
android:layout_height= "match_parent" />
</LinearLayout>
主要的三个View文件：
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.widget.RelativeLayout;
/**
* @ClassName: ClipImageLayout
* @Description:
* @date 2015 -5 -10 下午10:22:24
*/
public class ClipImageLayout extends RelativeLayout {
private ClipZoomImageView mZoomImageView;
private ClipImageBorderView mClipImageView;
private int mHorizontalPadding = 0; // 这里测试，直接写死了大小，真正使用过程中，可以提取为自定义属性
public ClipImageLayout(Context context, AttributeSet attrs) {
super(context, attrs);
mZoomImageView = new ClipZoomImageView(context);
mClipImageView = new ClipImageBorderView(context);
android.view.ViewGroup.LayoutParams lp = new LayoutParams(
android.view.ViewGroup.LayoutParams. MATCH_PARENT,
android.view.ViewGroup.LayoutParams. MATCH_PARENT);
this.addView( mZoomImageView, lp);
this.addView( mClipImageView, lp);
// 计算padding的px
mHorizontalPadding = ( int) TypedValue. applyDimension(
TypedValue. COMPLEX_UNIT_DIP, mHorizontalPadding, getResources()
.getDisplayMetrics());
mZoomImageView.setHorizontalPadding( mHorizontalPadding);
mClipImageView.setHorizontalPadding( mHorizontalPadding);
}
public void setImageDrawable(Drawable drawable) {
mZoomImageView.setImageDrawable(drawable);
}
public void setImageBitmap(Bitmap bitmap) {
mZoomImageView.setImageBitmap(bitmap);
}
/**
*对外公布设置边距的方法,单位为 dp
*
* @param mHorizontalPadding
*/
public void setHorizontalPadding( int mHorizontalPadding) {
this. mHorizontalPadding = mHorizontalPadding;
}
/**
* 裁切图片
*
* @return
*/
public Bitmap clip() {
return mZoomImageView.clip();
}
}
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.View;
public class ClipImageBorderView extends View {
/**
* 水平方向与View的边距
*/
private int mHorizontalPadding;
/**
* 垂直方向与View的边距
*/
private int mVerticalPadding;
/**
* 绘制的矩形的宽度
*/
private int mWidth;
/**
* 边框的颜色，默认为白色
*/
private int mBorderColor = Color.parseColor("#FFFFFF" );
/**
* 边框的宽度单位 dp
*/
private int mBorderWidth = 1;
private Paint mPaint;
public ClipImageBorderView(Context context) {
this(context, null);
}
public ClipImageBorderView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public ClipImageBorderView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
mBorderWidth = ( int) TypedValue. applyDimension(
TypedValue. COMPLEX_UNIT_DIP, mBorderWidth, getResources()
.getDisplayMetrics());
mPaint = new Paint();
mPaint.setAntiAlias( true);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
// 计算矩形区域的宽度
mWidth = getWidth() - 2 * mHorizontalPadding;
// 计算距离屏幕垂直边界 的边据
mVerticalPadding = (getHeight() - mWidth) / 2;
mPaint.setColor(Color. parseColor("#aa000000"));
mPaint.setStyle(Style. FILL);
// 绘制左边1
canvas.drawRect(0, 0, mHorizontalPadding, getHeight(), mPaint);
// 绘制右边2
canvas.drawRect(getWidth() - mHorizontalPadding, 0, getWidth(),
getHeight(), mPaint);
// 绘制上边3
canvas.drawRect( mHorizontalPadding, 0, getWidth() - mHorizontalPadding,
mVerticalPadding, mPaint);
// 绘制下边4
canvas.drawRect( mHorizontalPadding, getHeight() - mVerticalPadding,
getWidth() - mHorizontalPadding, getHeight(), mPaint);
// 绘制外边框
mPaint.setColor( mBorderColor);
mPaint.setStrokeWidth( mBorderWidth);
mPaint.setStyle(Style. STROKE);
canvas.drawRect( mHorizontalPadding, mVerticalPadding, getWidth()
- mHorizontalPadding, getHeight() - mVerticalPadding, mPaint );
}
public void setHorizontalPadding( int mHorizontalPadding) {
this. mHorizontalPadding = mHorizontalPadding;
}
}
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.GestureDetector.SimpleOnGestureListener;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.ScaleGestureDetector.OnScaleGestureListener;
import android.view.View;
import android.view.View.OnTouchListener;
import android.view.ViewTreeObserver;
import android.widget.ImageView;
/**
* 缩放图片的View
*
*/
public class ClipZoomImageView extends ImageView implements
OnScaleGestureListener, OnTouchListener,
ViewTreeObserver.OnGlobalLayoutListener {
public static float SCALE_MAX = 4.0f;
private static float SCALE_MID = 2.0f;
/**
* 初始化时的缩放比例，如果图片宽或高大于屏幕，此值将小于0
*/
private float initScale = 1.0f;
private boolean once = true;
/**
* 用于存放矩阵的9个值
*/
private final float[] matrixValues = new float[9];
/**
* 缩放的手势检测
*/
private ScaleGestureDetector mScaleGestureDetector = null;
private final Matrix mScaleMatrix = new Matrix();
/**
* 用于双击检测
*/
private GestureDetector mGestureDetector;
private boolean isAutoScale;
private int mTouchSlop;
private float mLastX;
private float mLastY;
private boolean isCanDrag;
private int lastPointerCount;
/**
* 水平方向与View的边距
*/
private int mHorizontalPadding;
public ClipZoomImageView(Context context) {
this(context, null);
}
public ClipZoomImageView(Context context, AttributeSet attrs) {
super(context, attrs);
setScaleType(ScaleType. MATRIX);
mGestureDetector = new GestureDetector(context,
new SimpleOnGestureListener() {
@Override
public boolean onDoubleTap(MotionEvent e) {
if ( isAutoScale == true)
return true;
float x = e.getX();
float y = e.getY();
if (getScale() < SCALE_MID) {
ClipZoomImageView. this.postDelayed(
new AutoScaleRunnable(SCALE_MID, x, y), 16);
isAutoScale = true;
} else {
ClipZoomImageView. this.postDelayed(
new AutoScaleRunnable(initScale, x, y), 16);
isAutoScale = true;
}
return true;
}
});
mScaleGestureDetector = new ScaleGestureDetector(context, this);
this. setOnTouchListener(this);
}
/**
* 自动缩放的任务
*
*/
private class AutoScaleRunnable implements Runnable {
static final float BIGGER = 1.07f;
static final float SMALLER = 0.93f;
private float mTargetScale;
private float tmpScale;
/**
* 缩放的中心
*/
private float x;
private float y;
/**
* 传入目标缩放值，根据目标值与当前值，判断应该放大还是缩小
*
* @param targetScale
*/
public AutoScaleRunnable( float targetScale, float x, float y) {
this. mTargetScale = targetScale;
this. x = x;
this. y = y;
if (getScale() < mTargetScale) {
tmpScale = BIGGER;
} else {
tmpScale = SMALLER;
}
}
@Override
public void run() {
// 进行缩放
mScaleMatrix.postScale( tmpScale, tmpScale, x, y);
checkBorder();
setImageMatrix( mScaleMatrix);
final float currentScale = getScale();
// 如果值在合法范围内，继续缩放
if ((( tmpScale > 1f) && (currentScale < mTargetScale))
|| (( tmpScale < 1f) && ( mTargetScale < currentScale))) {
ClipZoomImageView. this.postDelayed( this, 16);
} else
// 设置为目标的缩放比例
{
final float deltaScale = mTargetScale / currentScale;
mScaleMatrix.postScale(deltaScale, deltaScale, x, y);
checkBorder();
setImageMatrix( mScaleMatrix);
isAutoScale = false;
}
}
}
@Override
public boolean onScale(ScaleGestureDetector detector) {
float scale = getScale();
float scaleFactor = detector.getScaleFactor();
if (getDrawable() == null)
return true;
/**
* 缩放的范围控制
*/
if ((scale < SCALE_MAX && scaleFactor > 1.0f)
|| (scale > initScale && scaleFactor < 1.0f)) {
/**
* 最大值最小值判断
*/
if (scaleFactor * scale < initScale) {
scaleFactor = initScale / scale;
}
if (scaleFactor * scale > SCALE_MAX) {
scaleFactor = SCALE_MAX / scale;
}
/**
* 设置缩放比例
*/
mScaleMatrix.postScale(scaleFactor, scaleFactor,
detector.getFocusX(), detector.getFocusY());
checkBorder();
setImageMatrix( mScaleMatrix);
}
return true;
}
/**
* 根据当前图片的Matrix获得图片的范围
*
* @return
*/
private RectF getMatrixRectF() {
Matrix matrix = mScaleMatrix;
RectF rect = new RectF();
Drawable d = getDrawable();
if ( null != d) {
rect.set(0, 0, d.getIntrinsicWidth(), d.getIntrinsicHeight());
matrix.mapRect(rect);
}
return rect;
}
@Override
public boolean onScaleBegin(ScaleGestureDetector detector) {
return true;
}
@Override
public void onScaleEnd(ScaleGestureDetector detector) {
}
@Override
public boolean onTouch(View v, MotionEvent event) {
if ( mGestureDetector.onTouchEvent(event))
return true;
mScaleGestureDetector.onTouchEvent(event);
float x = 0, y = 0;
// 拿到触摸点的个数
final int pointerCount = event.getPointerCount();
// 得到多个触摸点的x与y均值
for ( int i = 0; i < pointerCount; i++) {
x += event.getX(i);
y += event.getY(i);
}
x = x / pointerCount;
y = y / pointerCount;
/**
* 每当触摸点发生变化时，重置mLasX , mLastY
*/
if (pointerCount != lastPointerCount) {
isCanDrag = false;
mLastX = x;
mLastY = y;
}
lastPointerCount = pointerCount;
switch (event.getAction()) {
case MotionEvent. ACTION_MOVE:
float dx = x - mLastX;
float dy = y - mLastY;
if (! isCanDrag) {
isCanDrag = isCanDrag(dx, dy);
}
if ( isCanDrag) {
if (getDrawable() != null) {
RectF rectF = getMatrixRectF();
// 如果宽度小于屏幕宽度，则禁止左右移动
if (rectF.width() <= getWidth() - mHorizontalPadding * 2) {
dx = 0;
}
// 如果高度小雨屏幕高度，则禁止上下移动
if (rectF.height() <= getHeight() - getHVerticalPadding()
* 2) {
dy = 0;
}
mScaleMatrix.postTranslate(dx, dy);
checkBorder();
setImageMatrix( mScaleMatrix);
}
}
mLastX = x;
mLastY = y;
break;
case MotionEvent. ACTION_UP:
case MotionEvent. ACTION_CANCEL:
lastPointerCount = 0;
break;
}
return true;
}
/**
* 获得当前的缩放比例
*
* @return
*/
public final float getScale() {
mScaleMatrix.getValues( matrixValues);
return matrixValues[Matrix. MSCALE_X];
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
getViewTreeObserver().addOnGlobalLayoutListener( this);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
getViewTreeObserver(). removeGlobalOnLayoutListener( this);
}
/**
* 垂直方向与View的边距
*/
// private int getHVerticalPadding();
@Override
public void onGlobalLayout() {
if ( once) {
Drawable d = getDrawable();
if (d == null)
return;
int width = getWidth();
int height = getHeight();
// 拿到图片的宽和高
int drawableW = d.getIntrinsicWidth();
int drawableH = d.getIntrinsicHeight();
float scale = 1.0f;
int frameSize = getWidth() - mHorizontalPadding * 2;
// 大图
if (drawableW > frameSize && drawableH < frameSize) {
scale = 1.0f * frameSize / drawableH;
} else if (drawableH > frameSize && drawableW < frameSize) {
scale = 1.0f * frameSize / drawableW;
} else if (drawableW > frameSize && drawableH > frameSize) {
float scaleW = frameSize * 1.0f / drawableW;
float scaleH = frameSize * 1.0f / drawableH;
scale = Math. max(scaleW, scaleH);
}
// 太小的图片放大处里
if (drawableW < frameSize && drawableH > frameSize) {
scale = 1.0f * frameSize / drawableW;
} else if (drawableH < frameSize && drawableW > frameSize) {
scale = 1.0f * frameSize / drawableH;
} else if (drawableW < frameSize && drawableH < frameSize) {
float scaleW = 1.0f * frameSize / drawableW;
float scaleH = 1.0f * frameSize / drawableH;
scale = Math. max(scaleW, scaleH);
}
initScale = scale;
SCALE_MID = initScale * 2;
SCALE_MAX = initScale * 4;
mScaleMatrix.postTranslate((width - drawableW) / 2,
(height - drawableH) / 2);
mScaleMatrix.postScale(scale, scale, getWidth() / 2,
getHeight() / 2);
// 图片移动至屏幕中心
setImageMatrix( mScaleMatrix);
once = false;
}
}
/**
* 剪切图片，返回剪切后的bitmap对象
*
* @return
*/
public Bitmap clip() {
Bitmap bitmap = Bitmap. createBitmap(getWidth(), getHeight(),
Bitmap.Config. ARGB_8888);
Canvas canvas = new Canvas(bitmap);
draw(canvas);
return Bitmap. createBitmap(bitmap, mHorizontalPadding,
getHVerticalPadding(), getWidth() - 2 * mHorizontalPadding,
getWidth() - 2 * mHorizontalPadding);
}
/**
* 边界检测
*/
private void checkBorder() {
RectF rect = getMatrixRectF();
float deltaX = 0;
float deltaY = 0;
int width = getWidth();
int height = getHeight();
// 如果宽或高大于屏幕，则控制范围 ; 这里的0.001是因为精度丢失会产生问题，但是误差一般很小，所以我们直接加了一个0.01
if (rect.width() + 0.01 >= width - 2 * mHorizontalPadding) {
if (rect. left > mHorizontalPadding) {
deltaX = -rect. left + mHorizontalPadding;
}
if (rect. right < width - mHorizontalPadding) {
deltaX = width - mHorizontalPadding - rect.right;
}
}
if (rect.height() + 0.01 >= height - 2 * getHVerticalPadding()) {
if (rect. top > getHVerticalPadding()) {
deltaY = -rect. top + getHVerticalPadding();
}
if (rect. bottom < height - getHVerticalPadding()) {
deltaY = height - getHVerticalPadding() - rect.bottom;
}
}
mScaleMatrix.postTranslate(deltaX, deltaY);
}
/**
* 是否是拖动行�?
*
* @param dx
* @param dy
* @return
*/
private boolean isCanDrag( float dx, float dy) {
return Math. sqrt((dx * dx) + (dy * dy)) >= mTouchSlop;
}
public void setHorizontalPadding( int mHorizontalPadding) {
this. mHorizontalPadding = mHorizontalPadding;
}
private int getHVerticalPadding() {
return (getHeight() - (getWidth() - 2 * mHorizontalPadding)) / 2;
}
}
DEMO下载地址：http://download.csdn.net/detail/q908555281/9311177