android自定义imageview实现圆角图片

2023-08-02 09:47:04 76
本文实例为大家分享了android自定义imageview实现圆角图片的具体代码，供大家参考，具体内容如下
自定义图片的属性，对图片进行圆角切割
实现效果图：
（1）在activity_main.xml文件布局，非常简单
2.1注意添加attrs文件，设置图片的属性，然后在java代码中引用属性，在xml文件使用相关属性
（2）MainActivity直接导入上面的布局即可，无需其他操作，如果要写监听或者其他操作，需要特别处理，这里仅仅提供显示
（3）开源的工具类，图片圆角转换工具类
packagecom.example.administrator.testz;



importandroid.content.Context;
importandroid.content.res.TypedArray;
importandroid.graphics.Bitmap;
importandroid.graphics.BitmapShader;
importandroid.graphics.Canvas;
importandroid.graphics.Color;
importandroid.graphics.ColorFilter;
importandroid.graphics.Matrix;
importandroid.graphics.Outline;
importandroid.graphics.Paint;
importandroid.graphics.Rect;
importandroid.graphics.RectF;
importandroid.graphics.Shader;
importandroid.graphics.drawable.BitmapDrawable;
importandroid.graphics.drawable.ColorDrawable;
importandroid.graphics.drawable.Drawable;
importandroid.net.Uri;
importandroid.os.Build;
importandroid.support.annotation.ColorInt;
importandroid.support.annotation.ColorRes;
importandroid.support.annotation.DrawableRes;
importandroid.support.annotation.RequiresApi;
importandroid.util.AttributeSet;
importandroid.view.MotionEvent;
importandroid.view.View;
importandroid.view.ViewOutlineProvider;
importandroid.widget.ImageView;

publicclassCircleImageViewextendsImageView{
//参考网址:https://github.com/hdodenhof/CircleImageView
privatestaticfinalScaleTypeSCALE_TYPE=ScaleType.CENTER_CROP;

privatestaticfinalBitmap.ConfigBITMAP_CONFIG=Bitmap.Config.ARGB_8888;
privatestaticfinalintCOLORDRAWABLE_DIMENSION=2;

privatestaticfinalintDEFAULT_BORDER_WIDTH=0;
privatestaticfinalintDEFAULT_BORDER_COLOR=Color.BLACK;
privatestaticfinalintDEFAULT_CIRCLE_BACKGROUND_COLOR=Color.TRANSPARENT;
privatestaticfinalbooleanDEFAULT_BORDER_OVERLAY=false;

privatefinalRectFmDrawableRect=newRectF();
privatefinalRectFmBorderRect=newRectF();

privatefinalMatrixmShaderMatrix=newMatrix();
privatefinalPaintmBitmapPaint=newPaint();
privatefinalPaintmBorderPaint=newPaint();
privatefinalPaintmCircleBackgroundPaint=newPaint();

privateintmBorderColor=DEFAULT_BORDER_COLOR;
privateintmBorderWidth=DEFAULT_BORDER_WIDTH;
privateintmCircleBackgroundColor=DEFAULT_CIRCLE_BACKGROUND_COLOR;

privateBitmapmBitmap;
privateBitmapShadermBitmapShader;
privateintmBitmapWidth;
privateintmBitmapHeight;

privatefloatmDrawableRadius;
privatefloatmBorderRadius;

privateColorFiltermColorFilter;

privatebooleanmReady;
privatebooleanmSetupPending;
privatebooleanmBorderOverlay;
privatebooleanmDisableCircularTransformation;

publicCircleImageView(Contextcontext){
super(context);

init();
}

publicCircleImageView(Contextcontext,AttributeSetattrs){
this(context,attrs,0);
}

publicCircleImageView(Contextcontext,AttributeSetattrs,intdefStyle){
super(context,attrs,defStyle);

TypedArraya=context.obtainStyledAttributes(attrs,R.styleable.CircleImageView,defStyle,0);

mBorderWidth=a.getDimensionPixelSize(R.styleable.CircleImageView_civ_border_width,DEFAULT_BORDER_WIDTH);
mBorderColor=a.getColor(R.styleable.CircleImageView_civ_border_color,DEFAULT_BORDER_COLOR);
mBorderOverlay=a.getBoolean(R.styleable.CircleImageView_civ_border_overlay,DEFAULT_BORDER_OVERLAY);

//Lookfordeprecatedciv_fill_colorifciv_circle_background_colorisnotset
if(a.hasValue(R.styleable.CircleImageView_civ_circle_background_color)){
mCircleBackgroundColor=a.getColor(R.styleable.CircleImageView_civ_circle_background_color,
DEFAULT_CIRCLE_BACKGROUND_COLOR);
}elseif(a.hasValue(R.styleable.CircleImageView_civ_fill_color)){
mCircleBackgroundColor=a.getColor(R.styleable.CircleImageView_civ_fill_color,
DEFAULT_CIRCLE_BACKGROUND_COLOR);
}

a.recycle();

init();
}

privatevoidinit(){
super.setScaleType(SCALE_TYPE);
mReady=true;

if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.LOLLIPOP){
setOutlineProvider(newOutlineProvider());
}

if(mSetupPending){
setup();
mSetupPending=false;
}
}

@Override
publicScaleTypegetScaleType(){
returnSCALE_TYPE;
}

@Override
publicvoidsetScaleType(ScaleTypescaleType){
if(scaleType!=SCALE_TYPE){
thrownewIllegalArgumentException(String.format("ScaleType%snotsupported.",scaleType));
}
}

@Override
publicvoidsetAdjustViewBounds(booleanadjustViewBounds){
if(adjustViewBounds){
thrownewIllegalArgumentException("adjustViewBoundsnotsupported.");
}
}

@Override
protectedvoidonDraw(Canvascanvas){
if(mDisableCircularTransformation){
super.onDraw(canvas);
return;
}

if(mBitmap==null){
return;
}

if(mCircleBackgroundColor!=Color.TRANSPARENT){
canvas.drawCircle(mDrawableRect.centerX(),mDrawableRect.centerY(),mDrawableRadius,mCircleBackgroundPaint);
}
canvas.drawCircle(mDrawableRect.centerX(),mDrawableRect.centerY(),mDrawableRadius,mBitmapPaint);
if(mBorderWidth>0){
canvas.drawCircle(mBorderRect.centerX(),mBorderRect.centerY(),mBorderRadius,mBorderPaint);
}
}

@Override
protectedvoidonSizeChanged(intw,inth,intoldw,intoldh){
super.onSizeChanged(w,h,oldw,oldh);
setup();
}

@Override
publicvoidsetPadding(intleft,inttop,intright,intbottom){
super.setPadding(left,top,right,bottom);
setup();
}

@Override
publicvoidsetPaddingRelative(intstart,inttop,intend,intbottom){
super.setPaddingRelative(start,top,end,bottom);
setup();
}

publicintgetBorderColor(){
returnmBorderColor;
}

publicvoidsetBorderColor(@ColorIntintborderColor){
if(borderColor==mBorderColor){
return;
}

mBorderColor=borderColor;
mBorderPaint.setColor(mBorderColor);
invalidate();
}

/**
*@deprecatedUse{@link#setBorderColor(int)}instead
*/
@Deprecated
publicvoidsetBorderColorResource(@ColorResintborderColorRes){
setBorderColor(getContext().getResources().getColor(borderColorRes));
}

publicintgetCircleBackgroundColor(){
returnmCircleBackgroundColor;
}

publicvoidsetCircleBackgroundColor(@ColorIntintcircleBackgroundColor){
if(circleBackgroundColor==mCircleBackgroundColor){
return;
}

mCircleBackgroundColor=circleBackgroundColor;
mCircleBackgroundPaint.setColor(circleBackgroundColor);
invalidate();
}

publicvoidsetCircleBackgroundColorResource(@ColorResintcircleBackgroundRes){
setCircleBackgroundColor(getContext().getResources().getColor(circleBackgroundRes));
}

/**
*Returnthecolordrawnbehindthecircle-shapeddrawable.
*
*@returnThecolordrawnbehindthedrawable
*
*@deprecatedUse{@link#getCircleBackgroundColor()}instead.
*/
@Deprecated
publicintgetFillColor(){
returngetCircleBackgroundColor();
}

/**
*Setacolortobedrawnbehindthecircle-shapeddrawable.Notethat
*thishasnoeffectifthedrawableisopaqueornodrawableisset.
*
*@paramfillColorThecolortobedrawnbehindthedrawable
*
*@deprecatedUse{@link#setCircleBackgroundColor(int)}instead.
*/
@Deprecated
publicvoidsetFillColor(@ColorIntintfillColor){
setCircleBackgroundColor(fillColor);
}

/**
*Setacolortobedrawnbehindthecircle-shapeddrawable.Notethat
*thishasnoeffectifthedrawableisopaqueornodrawableisset.
*
*@paramfillColorResThecolorresourcetoberesolvedtoacolorand
*drawnbehindthedrawable
*
*@deprecatedUse{@link#setCircleBackgroundColorResource(int)}instead.
*/
@Deprecated
publicvoidsetFillColorResource(@ColorResintfillColorRes){
setCircleBackgroundColorResource(fillColorRes);
}

publicintgetBorderWidth(){
returnmBorderWidth;
}

publicvoidsetBorderWidth(intborderWidth){
if(borderWidth==mBorderWidth){
return;
}

mBorderWidth=borderWidth;
setup();
}

publicbooleanisBorderOverlay(){
returnmBorderOverlay;
}

publicvoidsetBorderOverlay(booleanborderOverlay){
if(borderOverlay==mBorderOverlay){
return;
}

mBorderOverlay=borderOverlay;
setup();
}

publicbooleanisDisableCircularTransformation(){
returnmDisableCircularTransformation;
}

publicvoidsetDisableCircularTransformation(booleandisableCircularTransformation){
if(mDisableCircularTransformation==disableCircularTransformation){
return;
}

mDisableCircularTransformation=disableCircularTransformation;
initializeBitmap();
}

@Override
publicvoidsetImageBitmap(Bitmapbm){
super.setImageBitmap(bm);
initializeBitmap();
}

@Override
publicvoidsetImageDrawable(Drawabledrawable){
super.setImageDrawable(drawable);
initializeBitmap();
}

@Override
publicvoidsetImageResource(@DrawableResintresId){
super.setImageResource(resId);
initializeBitmap();
}

@Override
publicvoidsetImageURI(Uriuri){
super.setImageURI(uri);
initializeBitmap();
}

@Override
publicvoidsetColorFilter(ColorFiltercf){
if(cf==mColorFilter){
return;
}

mColorFilter=cf;
applyColorFilter();
invalidate();
}

@Override
publicColorFiltergetColorFilter(){
returnmColorFilter;
}

privatevoidapplyColorFilter(){
if(mBitmapPaint!=null){
mBitmapPaint.setColorFilter(mColorFilter);
}
}

privateBitmapgetBitmapFromDrawable(Drawabledrawable){
if(drawable==null){
returnnull;
}

if(drawableinstanceofBitmapDrawable){
return((BitmapDrawable)drawable).getBitmap();
}

try{
Bitmapbitmap;

if(drawableinstanceofColorDrawable){
bitmap=Bitmap.createBitmap(COLORDRAWABLE_DIMENSION,COLORDRAWABLE_DIMENSION,BITMAP_CONFIG);
}else{
bitmap=Bitmap.createBitmap(drawable.getIntrinsicWidth(),drawable.getIntrinsicHeight(),BITMAP_CONFIG);
}

Canvascanvas=newCanvas(bitmap);
drawable.setBounds(0,0,canvas.getWidth(),canvas.getHeight());
drawable.draw(canvas);
returnbitmap;
}catch(Exceptione){
e.printStackTrace();
returnnull;
}
}

privatevoidinitializeBitmap(){
if(mDisableCircularTransformation){
mBitmap=null;
}else{
mBitmap=getBitmapFromDrawable(getDrawable());
}
setup();
}

privatevoidsetup(){
if(!mReady){
mSetupPending=true;
return;
}

if(getWidth()==0&&getHeight()==0){
return;
}

if(mBitmap==null){
invalidate();
return;
}

mBitmapShader=newBitmapShader(mBitmap,Shader.TileMode.CLAMP,Shader.TileMode.CLAMP);

mBitmapPaint.setAntiAlias(true);
mBitmapPaint.setShader(mBitmapShader);

mBorderPaint.setStyle(Paint.Style.STROKE);
mBorderPaint.setAntiAlias(true);
mBorderPaint.setColor(mBorderColor);
mBorderPaint.setStrokeWidth(mBorderWidth);

mCircleBackgroundPaint.setStyle(Paint.Style.FILL);
mCircleBackgroundPaint.setAntiAlias(true);
mCircleBackgroundPaint.setColor(mCircleBackgroundColor);

mBitmapHeight=mBitmap.getHeight();
mBitmapWidth=mBitmap.getWidth();

mBorderRect.set(calculateBounds());
mBorderRadius=Math.min((mBorderRect.height()-mBorderWidth)/2.0f,(mBorderRect.width()-mBorderWidth)/2.0f);

mDrawableRect.set(mBorderRect);
if(!mBorderOverlay&&mBorderWidth>0){
mDrawableRect.inset(mBorderWidth-1.0f,mBorderWidth-1.0f);
}
mDrawableRadius=Math.min(mDrawableRect.height()/2.0f,mDrawableRect.width()/2.0f);

applyColorFilter();
updateShaderMatrix();
invalidate();
}

privateRectFcalculateBounds(){
intavailableWidth=getWidth()-getPaddingLeft()-getPaddingRight();
intavailableHeight=getHeight()-getPaddingTop()-getPaddingBottom();

intsideLength=Math.min(availableWidth,availableHeight);

floatleft=getPaddingLeft()+(availableWidth-sideLength)/2f;
floattop=getPaddingTop()+(availableHeight-sideLength)/2f;

returnnewRectF(left,top,left+sideLength,top+sideLength);
}

privatevoidupdateShaderMatrix(){
floatscale;
floatdx=0;
floatdy=0;

mShaderMatrix.set(null);

if(mBitmapWidth*mDrawableRect.height()>mDrawableRect.width()*mBitmapHeight){
scale=mDrawableRect.height()/(float)mBitmapHeight;
dx=(mDrawableRect.width()-mBitmapWidth*scale)*0.5f;
}else{
scale=mDrawableRect.width()/(float)mBitmapWidth;
dy=(mDrawableRect.height()-mBitmapHeight*scale)*0.5f;
}

mShaderMatrix.setScale(scale,scale);
mShaderMatrix.postTranslate((int)(dx+0.5f)+mDrawableRect.left,(int)(dy+0.5f)+mDrawableRect.top);

mBitmapShader.setLocalMatrix(mShaderMatrix);
}

@Override
publicbooleanonTouchEvent(MotionEventevent){
returninTouchableArea(event.getX(),event.getY())&&super.onTouchEvent(event);
}

privatebooleaninTouchableArea(floatx,floaty){
returnMath.pow(x-mBorderRect.centerX(),2)+Math.pow(y-mBorderRect.centerY(),2)<=Math.pow(mBorderRadius,2);
}

@RequiresApi(api=Build.VERSION_CODES.LOLLIPOP)
privateclassOutlineProviderextendsViewOutlineProvider{

@Override
publicvoidgetOutline(Viewview,Outlineoutline){
Rectbounds=newRect();
mBorderRect.roundOut(bounds);
outline.setRoundRect(bounds,bounds.width()/2.0f);
}

}

}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。
android自定义imageview实现圆角图片

热门推荐

随机推荐
