上传本地相册还有照片加裁剪功能

最新推荐文章于 2025-03-18 17:31:43 发布

冰凉小黑屋

最新推荐文章于 2025-03-18 17:31:43 发布

阅读量1.4k

点赞数

分类专栏：新的开始

本文链接：https://blog.youkuaiyun.com/a327037419/article/details/51458820

版权

新的开始专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了一种在Android应用中实现拍照、选取图片及图片裁剪的功能。具体包括弹出选择框、启动相机与相册、处理返回结果并进行图片裁剪等步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

首页的弹出框:

/**
	 * 
	 * 拍照弹出选择框
	 * 
	 * @param tackPhotoCallBack
	 * @param selectPhotoCallBack
	 */
	public static  void showTakePicturePopupWindow(BaseActivity activity,final DialogListener tackPhotoListener,final DialogListener selectPhotoListener) {
		View view = View.inflate(activity, R.layout.dialog_take_photo, null);
		final PopupWindow mPop;
		mPop = new PopupWindow(view, LayoutParams.MATCH_PARENT,LayoutParams.WRAP_CONTENT, true);
		mPop.setOutsideTouchable(true);
		mPop.setFocusable(true);
		mPop.setBackgroundDrawable(new ColorDrawable(0));
		mPop.setAnimationStyle(R.style.anim_popupwindows);
		view.findViewById(R.id.v_outArea).setOnClickListener(
				new OnClickListener() {
					@Override
					public void onClick(View v) {
						mPop.dismiss();
					}
				});
		view.findViewById(R.id.tv_take_photo).setOnClickListener(
				new OnClickListener() {
					@Override
					public void onClick(View v) {
						if (tackPhotoListener != null)
							tackPhotoListener.handleMessage();
						mPop.dismiss();
					}
				});
		view.findViewById(R.id.tv_select_photo).setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				if (selectPhotoListener != null)
					selectPhotoListener.handleMessage();
				mPop.dismiss();
			}
		});
		view.findViewById(R.id.txt_cancel).setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				mPop.dismiss();
			}
		});
		mPop.showAtLocation(view.findViewById(R.id.layout_root),Gravity.CENTER, 0, 0);
	}

layou文件:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/layout_root"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical" >
    <View
        android:id="@+id/v_outArea"
        android:layout_width="fill_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:alpha="0.3"
        android:background="@android:color/background_dark" />
    <LinearLayout
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical" >
        <TextView
            android:id="@+id/tv_take_photo"
            android:layout_width="match_parent"
            android:layout_height="@dimen/dp_48"
            android:background="@drawable/bg_white_round"
            android:clickable="true"
            android:gravity="center"
            android:text="@string/take_pic"
            android:textColor="@color/color_333333"
            android:textSize="@dimen/sp_18" />
        <View style="@style/horizontalSeparation" />
        <TextView
            android:id="@+id/tv_select_photo"
            android:layout_width="match_parent"
            android:layout_height="@dimen/dp_48"
            android:background="@drawable/bg_white_round"
            android:clickable="true"
            android:gravity="center"
            android:text="@string/select_pic"
            android:textColor="@color/color_333333"
            android:textSize="@dimen/sp_18" />
		<View android:layout_width="fill_parent"
		    android:layout_height="8dp"
		    android:background="@android:color/background_dark"
		    android:alpha="0.3"/>
        <TextView
            android:id="@+id/txt_cancel"
            android:layout_width="match_parent"
            android:layout_height="@dimen/dp_48"
            android:background="@drawable/bg_white_round"
            android:clickable="true"
            android:gravity="center"
            android:text="@string/cancel"
            android:textColor="@color/color_05acff"
            android:textSize="@dimen/sp_18" />
    </LinearLayout>

</LinearLayout>

然后是调用 :

				DialogHelper.showTakePicturePopupWindow(activity, new DialogListener() {
					
					@Override
					public void handleMessage() {  
//						点击相机走这里
						mPhotoUri = Uri.fromFile(new File(FileUtils.createFile(activity, FileUtils.FILE_TYPE_IMAGE)));
						// 相机 获取图片  mPhotoUri : file:///storage/emulated/0/shishi/image/1460974445049.jpg
			    		ActivityUtils.switchToCapturePhoto(activity, mPhotoUri,Constants.RequestCode.REQUEST_TAKE_PHOTO);
//			    		  startActivityForquest  第一步
					}
				}, new DialogListener() {
					@Override
					public void handleMessage() {
						//选择图片
						ActivityUtils.switchToPickPhoto(activity, Constants.RequestCode.REQUEST_SELECT_PICTURE);
					}
				});
				//ActivityUtils.switchToForResult(activity, PhotoClipperActivity.class,Constants.RequestCode.request_code);

照片还有相册 ---->2个 activity

/**
	 * 手机相册选择图片
	 * 
	 * @param activity
	 * @param requestCode
	 * @author zkx
	 */
	public static void switchToPickPhoto(Activity activity, int requestCode) {
		Intent intent = new Intent(Intent.ACTION_PICK,android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
		intent.setType("image/*");
		activity.startActivityForResult(intent, requestCode);
	}
	/**
	 * 相机获取图片
	 * @param activity
	 * @param uri
	 * @param requestCode
	 */
	public static void switchToCapturePhoto(Activity activity, Uri uri,int requestCode) {
		Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
		intent.putExtra(MediaStore.EXTRA_OUTPUT, uri);
		activity.startActivityForResult(intent, requestCode);
	}

接收照片和选择完图片的返回结果跳转到裁剪界面 ------->:

@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		if (resultCode != RESULT_OK) {
			return;
		}
		switch (requestCode) {
			case Constants.RequestCode.request_code: // 修改用户头像拍照或者选择照片 第四步
				String filePath = data.getStringExtra("filePath");  ///点击保存后走这里
				if (filePath != null && filePath.length() > 0) {
				
						// 显示
						ImageLoaderHelper.displayImage(iv_head_photo, filePath); //设置view 样子
						RequestParams params=new RequestParams();
						try {
							params.put("uuid", user.getUuid());
							params.put("image", new File(filePath));
							uploadAvatarRequest(params); //保存到服务器
						} catch (Exception e) {
							e.printStackTrace();
						}
						
						
					
					
				}
				break;
			case Constants.RequestCode.REQUEST_SELECT_PICTURE://拿到请求的结果 选择照片 : 第二步
				 if (data != null) { 
					Uri uri = FileUtils.getPickPhotoUri(activity, data); // 转uri格式
					String fileDir = uri.getPath();// 
					switchToClip(fileDir);
				 }
				break;
			case Constants.RequestCode.REQUEST_TAKE_PHOTO:  //照相 拿到结果,
				 if (mPhotoUri != null) {
					String fileDir = mPhotoUri.getPath();
					switchToClip(fileDir);
				 }
				break;
		}
	}

裁剪 --->

	/**
	 * 跳转到裁剪页面
	 * @param filePath
	 */
	public void switchToClip(String filePath){ //  第三步
		Intent intent=new Intent(activity, PhotoClipperActivity.class);
		intent.putExtra("filePath", filePath);
		ActivityUtils.switchToForResult(activity, intent,Constants.RequestCode.request_code);
	}

裁剪类 -->

/**
 * @Description 选择照片并裁剪
 */
public class PhotoClipperActivity extends BaseActivity {
	private ClipImageLayout  clip_image_layout;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_photo_clipper);
		showNavRightTv(true, true,R.string.mine_personal_icon, R.string.save, new View.OnClickListener() {
			
			@Override
			public void onClick(View v) {
				clipPhoto();
			}
		});
		clip_image_layout=(ClipImageLayout) findViewById(R.id.clip_image_layout);
		clip_image_layout.setImagePath(getIntent().getStringExtra("filePath"));
	}
	/**
	 * 图片裁剪
	 */
	public void clipPhoto(){
		Bitmap bitmap = clip_image_layout.clip();
		String filePath=null;
		try {
			filePath = FileUtils.writeBitmap(bitmap, activity);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		Intent intent = new Intent();
		intent.putExtra("filePath", filePath);
		setResult(RESULT_OK, intent);
		finish();
	}
}

ClipImageLayout: 第一个自定义view :

package com.free.shishi.third.clip;
import java.io.File;
import java.io.IOException;

import com.free.shishi.R;
import com.free.shishi.utils.BitmapUtils;

import android.content.Context;
import android.graphics.Bitmap;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.widget.RelativeLayout;


public class ClipImageLayout extends RelativeLayout
{

	private ClipZoomImageView mZoomImageView;
	private ClipImageBorderView mClipImageView;

	/**
	 * 这里测试，直接写死了大小，真正使用过程中，可以提取为自定义属性
	 */
	private int mHorizontalPadding = 20;

	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);
	}
	/**
	 * 设置图片
	 * @param imagePath
	 */
	public void setImagePath(String imagePath){
		/**
		 * 这里测试，直接写死了图片，真正使用过程中，可以提取为自定义属性
		 */
		try {
			mZoomImageView.setImageBitmap(BitmapUtils.decodeFile(new File(imagePath)));
		} catch (IOException e) {
			e.printStackTrace();
		};
	}
	/**
	 * 对外公布设置边距的方法,单位为dp
	 * 
	 * @param mHorizontalPadding
	 */
	public void setHorizontalPadding(int mHorizontalPadding)
	{
		this.mHorizontalPadding = mHorizontalPadding;
	}

	/**
	 * 裁切图片
	 * 
	 * @return
	 */
	public Bitmap clip()
	{
		return mZoomImageView.clip();
	}

}

package com.free.shishi.third.clip;
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.util.Log;
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;
<span style="white-space:pre">	</span>''

 - ->自定义 ImageView


public class ClipZoomImageView extends ImageView implements
		OnScaleGestureListener, OnTouchListener,
		ViewTreeObserver.OnGlobalLayoutListener

{

	private static final String TAG = ClipZoomImageView.class.getSimpleName();
	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;

	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);
	}

	/**
	 * 自动缩放的任务
	 * 
	 * @author zhy
	 * 
	 */
	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() - mVerticalPadding * 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);
	}

	@SuppressWarnings("deprecation")
	@Override
	protected void onDetachedFromWindow()
	{
		super.onDetachedFromWindow();
		getViewTreeObserver().removeGlobalOnLayoutListener(this);
	}

	/**
	 * 水平方向与View的边距
	 */
	private int mHorizontalPadding;
	/**
	 * 垂直方向与View的边距
	 */
	private int mVerticalPadding;

	@Override
	public void onGlobalLayout()
	{
		if (once)
		{
			Drawable d = getDrawable();
			if (d == null)
				return;
			// 垂直方向的边距
			mVerticalPadding = (getHeight() - (getWidth() - 2 * mHorizontalPadding)) / 2;

			int width = getWidth();
			int height = getHeight();
			// 拿到图片的宽和高
			int dw = d.getIntrinsicWidth();
			int dh = d.getIntrinsicHeight();
			float scale = 1.0f;
			if (dw < getWidth() - mHorizontalPadding * 2
					&& dh > getHeight() - mVerticalPadding * 2)
			{
				scale = (getWidth() * 1.0f - mHorizontalPadding * 2) / dw;
			}

			if (dh < getHeight() - mVerticalPadding * 2
					&& dw > getWidth() - mHorizontalPadding * 2)
			{
				scale = (getHeight() * 1.0f - mVerticalPadding * 2) / dh;
			}

			if (dw < getWidth() - mHorizontalPadding * 2
					&& dh < getHeight() - mVerticalPadding * 2)
			{
				float scaleW = (getWidth() * 1.0f - mHorizontalPadding * 2)
						/ dw;
				float scaleH = (getHeight() * 1.0f - mVerticalPadding * 2) / dh;
				scale = Math.max(scaleW, scaleH);
			}

			initScale = scale;
			SCALE_MID = initScale * 2;
			SCALE_MAX = initScale * 4;
			mScaleMatrix.postTranslate((width - dw) / 2, (height - dh) / 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,
				mVerticalPadding, getWidth() - 2 * mHorizontalPadding,
				getWidth() - 2 * mHorizontalPadding);
	}

	/**
	 * 边界检测
	 */
	private void checkBorder()
	{

		RectF rect = getMatrixRectF();
		float deltaX = 0;
		float deltaY = 0;

		int width = getWidth();
		int height = getHeight();
		Log.e(TAG, "rect.width() =  " + rect.width()
				+ " , width - 2 * mHorizontalPadding ="
				+ (width - 2 * mHorizontalPadding));

		// 如果宽或高大于屏幕，则控制范围 ; 这里的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 * mVerticalPadding)
		{
			if (rect.top > mVerticalPadding)
			{
				deltaY = -rect.top + mVerticalPadding;
			}
			if (rect.bottom < height - mVerticalPadding)
			{
				deltaY = height - mVerticalPadding - 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;
	}

}

ClipImageBorderView -->

package com.free.shishi.third.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;

}


}

裁剪完回到 onActivityForResult()

case Constants.RequestCode.request_code: // 修改用户头像拍照或者选择照片 第四步

如果原作者看到了,要求写上转载地址, 联系我 ,,,我会马上加上;

完善了, 代码也是从网上拷贝, 经测试可以拷贝直接使用;哈哈

上传本地相册还有照片 加 裁剪功能

上传本地相册还有照片加裁剪功能