Android：自定义imageview实现两条线裁剪图片，不在区域内显示阴影

package com.example.customimageview;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.Window;
import android.widget.Button;
import android.widget.ScrollView;

public class MainActivity extends Activity {

private static final String TAG = "customimageview";
private MyImageView img;
private ScrollView sv;
private static final String CROP_IMAGE_PATH = "/storage/emulated/0/3.png";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_main);

Bitmap bmp = BitmapFactory.decodeFile(CROP_IMAGE_PATH);
img = (MyImageView) findViewById(R.id.long_pic);
img.setImageBitmap(bmp);
Button btn = (Button) findViewById(R.id.btn);
Log.i(TAG, "onCreate ");
sv = (ScrollView) findViewById(R.id.scrollView);
btn.setOnClickListener(new View.OnClickListener() {

@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Log.i(TAG, "onClick(View v) enter");
savedBitmap(img.getClippedBitmap());
}
});

sv.setOnTouchListener(new View.OnTouchListener() {

@Override
public boolean onTouch(View v, MotionEvent event) {
// TODO Auto-generated method stub
img.getParent().requestDisallowInterceptTouchEvent(false);
return false;
}
});
}

private void savedBitmap(Bitmap bitmap) {
Log.i(TAG, "savedBitmap(Bitmap bitmap)");
if (bitmap != null) {
Log.i(TAG, "bitmap != null");
try {
long current = System.currentTimeMillis();
Date date = new Date(current);
SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
String filename = format.format(date);
StringBuilder builder = new StringBuilder();
builder.append(filename);
builder.append(".png");
filename = builder.toString();
File fileImage = new File("/sdcard/", filename);
if (!fileImage.exists()) {
fileImage.createNewFile();
Log.i(TAG, "image file created");
}
FileOutputStream out = new FileOutputStream(fileImage);
if (out != null) {
bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
out.flush();
out.close();
Intent media = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
Uri contentUri = Uri.fromFile(fileImage);
media.setData(contentUri);
this.sendBroadcast(media);
Log.i(TAG, "screen image saved");
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
} else {
Log.i(TAG, "savedBitmap(Bitmap bitmap) = null");
}
}
}

<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="${relativePackage}.${activityClass}" >

<Button
android:id="@+id/btn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:text="save" />

<ScrollView
android:id="@+id/scrollView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/btn"
android:layout_centerHorizontal="true" >

<LinearLayout
android:id="@+id/Linear"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_alignParentEnd="true"
android:layout_below="@+id/top_text"
android:layout_marginLeft="10dp"
android:layout_marginRight="10dp"
android:orientation="vertical" >

<com.example.customimageview.MyImageView
android:id="@+id/long_pic"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal" />
</LinearLayout>
</ScrollView>

</RelativeLayout>

package com.example.customimageview;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PointF;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.widget.ImageView;

/**
* 图片剪裁控件; 注意事项： 1.在为ClipImageView设置图片时（调用setImageResource(),
* setImageDrawable(), setImageBitmap()）,要注意图片的大小，即注意Bitmap可能导致 程序出现oom的问题。
* 2.如对剪裁图片质量无过高要求，建议调用setImageResourceSecure(), setImageDrawableSecure(),
* setImageBitmapSecure()设置图片。
*
*/
public class MyImageView extends ImageView {

private static final String TAG = "customimageview";

/**
* mClipFrameBorderWidth:剪裁框的边框宽度;TOUCH_FIELD:触摸范围;UP_DOWN_LENGTH:剪裁最小高度
*/
private final float density = getResources().getDisplayMetrics().density; // 密度
private float mClipFrameBorderWidth = 1 * density; // 剪裁框的边框宽度
private static final float TOUCH_FIELD = 20f;
private static final float UP_DOWN_LENGTH = 50f;

/**
* 初始图片大小
*/
private int imWidth;
private int imHeight;

private boolean showClipFrame = true; // 是否显示剪裁框

private String mClipFrameColor = "#FFFFFFFF"; // 剪裁框的边框颜色
private String mShadowColor = "#99000000"; // 阴影颜色

private Paint mShadowPaint;
private Paint mClipFramePaint;
/**
* 剪裁框外的阴影
*/
private Rect mRectTopShadow;
private Rect mRectBottomShadow;
/**
* 剪裁框:顶部条和底部条
*/
private int mTopLineY = 100; // 默认顶部条Y坐标
private int mBottomLineY = 200; // 默认底部条Y坐标
private int mLineWidth;

private PointF mLastPoint = new PointF();

private int mShadowUpY; // 顶部阴影高度
private int mShadowDownY; // 底部阴影高度
/**
* 设置在ImageView中的Bitmap
*/
private Bitmap source;

/**
* 触摸事件位置
*/
private int touchPos;
private static final int POS_TOP = 1;
private static final int POS_BOTTOM = 2;
private static final int POS_CENTER = 3;
private boolean mInterceptTouchEvent;

public MyImageView(Context context, AttributeSet attrs) {
super(context, attrs);
setAdjustViewBounds(true);

initPaint();
initRect();

post(new Runnable() {

@Override
public void run() {
imWidth = getWidth();
imHeight = getHeight();

Log.i(TAG, "imWidth: " + imWidth + " imHeight: " + imHeight);
mLineWidth = imWidth;
resolveClipFrameSize(); // 必要步骤，校正剪裁框大小，底部条不能超过图片大小

}
});
}

private void initPaint() {
mShadowPaint = new Paint();
mShadowPaint.setColor(Color.parseColor(mShadowColor));

mClipFramePaint = new Paint();
mClipFramePaint.setStyle(Paint.Style.STROKE); // 设置为空心
mClipFramePaint.setStrokeWidth(mClipFrameBorderWidth); // 设置边框宽度
setClipFrameColor(Color.BLUE); // 设置颜色
}

private void initRect() {
/**
* 阴影区域
*/
mRectTopShadow = new Rect();
mRectBottomShadow = new Rect();
}

/**
* 设置剪裁框外的阴影
*
* @param x
*            剪裁框当前的左上角X坐标
* @param y
*            剪裁框当前的左上角Y坐标
*/

/**
* 方法已对resId指向的图片进行压缩处理， 用此方法设置图片，剪裁后的相片质量相对 较差，但可简单避免Bitmap的OOM；如需
* 对原图进行裁剪，请直接调用setImageResource（）
*
* @param resId
*/
public void setImageResourceSecure(int resId) {
Bitmap bm = BitmapFactory.decodeResource(getResources(), resId);
setImageBitmap(processBitmap(bm));
}

/**
* 方法已对drawable指向的图片进行压缩处理， 用此方法设置图片，剪裁后的相片质量相对 较差，但可简单避免Bitmap的OOM；如需
* 对原图进行裁剪，请直接调用setImageDrawable（）
*
* @param drawable
*/
public void setImageDrawableSecure(Drawable drawable) {
if (drawable == null)
throw new IllegalArgumentException("drawable 不能为null");
BitmapDrawable bd = (BitmapDrawable) drawable;
setImageBitmap(processBitmap(bd.getBitmap()));
}

/**
* 方法已对bm指向的图片进行压缩处理， 用此方法设置图片，剪裁后的相片质量相对 较差，但可简单避免Bitmap的OOM；如需
* 对原图进行裁剪，请直接调用setImageBitmap（）
*
* @param bm
*/
public void setImageBitmapSecure(Bitmap bm) {
setImageBitmap(processBitmap(bm));
}

/**
* 对Bitmap进行简单的处理，适当地压缩图片大小
*
* @param bm
* @return
*/
private Bitmap processBitmap(Bitmap bm) {
if (bm == null)
throw new IllegalArgumentException("bitmap 不能为null");

int screenWidth = getResources().getDisplayMetrics().widthPixels;
int screenHeight = getResources().getDisplayMetrics().heightPixels;
int bmWidth = bm.getWidth();
int bmHeight = bm.getHeight();
if (bmWidth < screenWidth || bmHeight < screenHeight)
return bm;

float scale = (float) screenWidth / bmWidth;
Bitmap bitmap = Bitmap.createScaledBitmap(bm, screenWidth, (int) (bmHeight * scale), true);
bm.recycle();
return bitmap;
}

/**
* 获取设置在ClipImageView中的Bitmap
*
* @return
*/
public Bitmap getSourceBitmap() {
if (source != null)
return source;

Drawable d = getDrawable();
if (d == null) {
return null;
}

BitmapDrawable bd = (BitmapDrawable) d;
source = bd.getBitmap();
return source;
}

/**
* 获取ImageView对原图的缩放比例
*
* @return
*/
public float getScale() {
if (getSourceBitmap() == null)
return 0f;

int bmWidth = source.getWidth();
int bmHeight = source.getHeight();
float scale = Math.min((float) bmWidth / imWidth, (float) bmHeight / imHeight);
return scale;
}

/**
* 获取剪裁好的bitmap
*
* @return
*/
public Bitmap getClippedBitmap() {
float scale = getScale();
Log.i(TAG, "getClippedBitmap() scale: " + scale);
if (scale > 0 && source != null) {
/*
* Log.i(TAG, "ClipImageUtils.clipImage() currX: "+currX+" currY: "+
* currY+" mClipFrameWidth: "+mClipFrameWidth+" mClipFrameHeight: "
* +mClipFrameHeight);
*/

return ClipImageUtils.clipImage(source, 0, mTopLineY, // 剪裁图片
imWidth, mBottomLineY - mTopLineY, scale);
}
return null;
}

/**
* 设置剪裁框边框的颜色，支持#RRGGBB #AARRGGBB 'red', 'blue', 'green', 'black', 'white',
* 'gray', 'cyan', 'magenta', 'yellow', 'lightgray', 'darkgray', 'grey',
* 'lightgrey', 'darkgrey', 'aqua', 'fuschia', 'lime', 'maroon', 'navy',
* 'olive', 'purple', 'silver', 'teal'
*
* @param color
*/
public void setClipFrameColor(String color) {
mClipFramePaint.setColor(Color.parseColor(color));
}

public void setClipFrameColor(int color) {
mClipFramePaint.setColor(color);
}

/**
* 校正裁剪框的高，使其不能超过View的高
*/
private void resolveClipFrameSize() {
mBottomLineY = mBottomLineY >= imHeight ? imHeight : mBottomLineY;
}

/**
* 设置剪裁框的边框宽度
*
* @param w
*/
public void setClipFrameBorderWidth(float w) {
w = w < 0 ? 0 : w;
mClipFrameBorderWidth = w;
mClipFramePaint.setStrokeWidth(mClipFrameBorderWidth);
}

/**
* 顶部条的Y坐标
*
* @return
*/
public float getContentX() {
return mTopLineY;
}

/**
* 底部条的Y坐标
*
* @return
*/
public float getContentY() {
return mBottomLineY;
}

/**
* 获取剪裁内容的宽度
*
* @return
*/
public int getContentWidth() {
return (mBottomLineY - mTopLineY);
}

public int getImWidth() {
return imWidth;
}

public int getImHeight() {
return imHeight;
}

/**
* 设置是否显示剪裁框
*
* @param f
*/
public void setShowClipFrame(boolean f) {
showClipFrame = f;
}

@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (showClipFrame) {
drawShadowRegion(canvas);
drawClipFrame(canvas);
}
}

/**
* 绘制剪裁框外的阴影
*
* @param canvas
*/
private void drawShadowRegion(Canvas canvas) {
mRectTopShadow.set(0, 0, imWidth, mTopLineY);
mRectBottomShadow.set(0, mBottomLineY, imWidth, imHeight);
canvas.drawRect(mRectTopShadow, mShadowPaint);
canvas.drawRect(mRectBottomShadow, mShadowPaint);
}

/**
* 绘制剪裁框
*
* @param canvas
*/
private void drawClipFrame(Canvas canvas) {
canvas.drawLine(0, mTopLineY, mLineWidth, mTopLineY, mClipFramePaint);
canvas.drawLine(0, mBottomLineY, mLineWidth, mBottomLineY, mClipFramePaint);
}

@Override
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
setLastPosition(event);

touchPos = detectTouchPosition(event.getX(), event.getY());
getParent().requestDisallowInterceptTouchEvent(mInterceptTouchEvent);

break;
case MotionEvent.ACTION_MOVE:
onActionMove(event.getX(), event.getY());
setLastPosition(event);
break;
case MotionEvent.ACTION_UP:
break;
}
return true;
}

private void onActionMove(float x, float y) {
// TODO Auto-generated method stub
float deltaX = x - mLastPoint.x;
float deltaY = y - mLastPoint.y;

switch (touchPos) {
case POS_CENTER:

break;
case POS_TOP:
resetTop(deltaY);
break;
case POS_BOTTOM:
resetBottom(deltaY);
break;
default:

break;
}

invalidate();

}

private void resetBottom(float deltaY) {
// TODO Auto-generated method stub
mBottomLineY += deltaY;
fixBottomLine();
}

private void fixBottomLine() {
// TODO Auto-generated method stub
if (mBottomLineY > imHeight) {
mBottomLineY = imHeight;
}

if ((mBottomLineY - mTopLineY) < 2 * UP_DOWN_LENGTH) {
mBottomLineY = (int) (mTopLineY + 2 * UP_DOWN_LENGTH);
}
}

private void resetTop(float deltaY) {
// TODO Auto-generated method stub
mTopLineY += deltaY;
fixTopLine();
}

private void fixTopLine() {
// TODO Auto-generated method stub
if (mTopLineY < 0) {
mTopLineY = 0;
}

if ((mBottomLineY - mTopLineY) < 2 * UP_DOWN_LENGTH) {
mTopLineY = (int) (mBottomLineY - 2 * UP_DOWN_LENGTH);
}

}

private void setLastPosition(MotionEvent event) {
mLastPoint.x = event.getX();
mLastPoint.y = event.getY();
}

/**
* 判断触摸位置
*
* @param x
* @param y
* @return
*/
private int detectTouchPosition(float x, float y) {
if (x > TOUCH_FIELD && x < mLineWidth - TOUCH_FIELD && y > mTopLineY + TOUCH_FIELD
&& y < mBottomLineY - TOUCH_FIELD) {

mInterceptTouchEvent = false;  //不处理该区域的事件;scrollview处理

return POS_CENTER;
}

if (x > TOUCH_FIELD && x < mLineWidth - TOUCH_FIELD && y > mTopLineY - TOUCH_FIELD
&& y < mTopLineY + TOUCH_FIELD) {

mInterceptTouchEvent = true;  //处理该区域的事件

return POS_TOP;
}
if (x > TOUCH_FIELD && x < mLineWidth - TOUCH_FIELD && y > mBottomLineY - TOUCH_FIELD
&& y < mBottomLineY + TOUCH_FIELD) {

mInterceptTouchEvent = true;  //处理该区域的事件

return POS_BOTTOM;
}
return -1;

}

}