Android使用CircleImageView实现圆形头像的方法

有时我们在应用中会用到圆形头像，下面是利用circleimageview实现圆形头像的演示，下面效果和代码，效果如图

实现起来也比较简单，先在项目中建一个circleimageview包用来存放circleimageview类，待会直接把circleimageview类复制到包里就可以使用了

然后，再建一个attrs.xml，其代码相当简单，定义了圆形边框宽度和颜色

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <declare-styleable name="circleimageview">
    <attr name="border_width" format="dimension" />
    <attr name="border_color" format="color" />
  </declare-styleable>
</resources>

然后是在自己应用的activity的布局文件中使用circleimageview了

<?xml version="1.0" encoding="utf-8"?>
<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="com.example.icontest.mainactivity">
  <circleimageview.circleimageview
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/circleimageview"
    android:layout_width="100dp"
    android:layout_height="100dp"
    android:layout_centerhorizontal="true"
    android:src="@mipmap/ic_launcher"
    app:border_width="2dp"
    app:border_color="#ccc"
     />
</relativelayout>

注意的是要写上circleimageview.circleimageview这个全路径，还要指定

xmlns:app=""

这个就是根据上面整个布局的

xmlns:android=""

来的，把res/android改为res-auto即可，然后再指定border_width和border_color两个属性即可
然后再activity中就直接可以利用id找到它了

circleimageview icon;
icon= (circleimageview) findviewbyid(r.id.circleimageview);

最后是circleimageview类的代码，这个网上随便就能找到，不过这里还是贴出来吧

package circleimageview;
import android.content.context;
import android.content.res.typedarray;
import android.graphics.bitmap;
import android.graphics.bitmapshader;
import android.graphics.canvas;
import android.graphics.color;
import android.graphics.matrix;
import android.graphics.paint;
import android.graphics.rectf;
import android.graphics.shader;
import android.graphics.drawable.bitmapdrawable;
import android.graphics.drawable.colordrawable;
import android.graphics.drawable.drawable;
import android.net.uri;
import android.util.attributeset;
import android.widget.imageview;
import com.example.icontest.r;
public class circleimageview extends imageview {
  private static final scaletype scale_type = scaletype.center_crop;
  private static final bitmap.config bitmap_config = bitmap.config.argb_8888;
  private static final int colordrawable_dimension = 2;
  private static final int default_border_width = 0;
  private static final int default_border_color = color.black;
  private final rectf mdrawablerect = new rectf();
  private final rectf mborderrect = new rectf();
  private final matrix mshadermatrix = new matrix();
  private final paint mbitmappaint = new paint();
  private final paint mborderpaint = new paint();
  private int mbordercolor = default_border_color;
  private int mborderwidth = default_border_width;
  private bitmap mbitmap;
  private bitmapshader mbitmapshader;
  private int mbitmapwidth;
  private int mbitmapheight;
  private float mdrawableradius;
  private float mborderradius;
  private boolean mready;
  private boolean msetuppending;
  public circleimageview(context context) {
   super(context);
   init();
  }
  public circleimageview(context context, attributeset attrs) {
   this(context, attrs, 0);
  }
  public circleimageview(context context, attributeset attrs, int defstyle) {
   super(context, attrs, defstyle);
   typedarray a = context.obtainstyledattributes(attrs, r.styleable.circleimageview, defstyle, 0);
   mborderwidth = a.getdimensionpixelsize(r.styleable.circleimageview_border_width, default_border_width);
   mbordercolor = a.getcolor(r.styleable.circleimageview_border_color, default_border_color);
   a.recycle();
   init();
  }
  private void init() {
   super.setscaletype(scale_type);
   mready = true;
   if (msetuppending) {
     setup();
     msetuppending = false;
   }
  }
  @override
  public scaletype getscaletype() {
   return scale_type;
  }
  @override
  public void setscaletype(scaletype scaletype) {
   if (scaletype != scale_type) {
     throw new illegalargumentexception(string.format("scaletype %s not supported.", scaletype));
   }
  }
  @override
  public void setadjustviewbounds(boolean adjustviewbounds) {
   if (adjustviewbounds) {
     throw new illegalargumentexception("adjustviewbounds not supported.");
   }
  }
  @override
  protected void ondraw(canvas canvas) {
   if (getdrawable() == null) {
     return;
   }
   canvas.drawcircle(getwidth() / 2, getheight() / 2, mdrawableradius, mbitmappaint);
   if (mborderwidth != 0) {
     canvas.drawcircle(getwidth() / 2, getheight() / 2, mborderradius, mborderpaint);
   }
  }
  @override
  protected void onsizechanged(int w, int h, int oldw, int oldh) {
   super.onsizechanged(w, h, oldw, oldh);
   setup();
  }
  public int getbordercolor() {
   return mbordercolor;
  }
  public void setbordercolor(int bordercolor) {
   if (bordercolor == mbordercolor) {
     return;
   }
   mbordercolor = bordercolor;
   mborderpaint.setcolor(mbordercolor);
   invalidate();
  }
  public int getborderwidth() {
   return mborderwidth;
  }
  public void setborderwidth(int borderwidth) {
   if (borderwidth == mborderwidth) {
     return;
   }
   mborderwidth = borderwidth;
   setup();
  }
  @override
  public void setimagebitmap(bitmap bm) {
   super.setimagebitmap(bm);
   mbitmap = bm;
   setup();
  }
  @override
  public void setimagedrawable(drawable drawable) {
   super.setimagedrawable(drawable);
   mbitmap = getbitmapfromdrawable(drawable);
   setup();
  }
  @override
  public void setimageresource(int resid) {
   super.setimageresource(resid);
   mbitmap = getbitmapfromdrawable(getdrawable());
   setup();
  }
  @override
  public void setimageuri(uri uri) {
   super.setimageuri(uri);
   mbitmap = getbitmapfromdrawable(getdrawable());
   setup();
  }
  private bitmap getbitmapfromdrawable(drawable drawable) {
   if (drawable == null) {
     return null;
   }
   if (drawable instanceof bitmapdrawable) {
     return ((bitmapdrawable) drawable).getbitmap();
   }
   try {
     bitmap bitmap;
     if (drawable instanceof colordrawable) {
      bitmap = bitmap.createbitmap(colordrawable_dimension, colordrawable_dimension, bitmap_config);
     } else {
      bitmap = bitmap.createbitmap(drawable.getintrinsicwidth(), drawable.getintrinsicheight(), bitmap_config);
     }
     canvas canvas = new canvas(bitmap);
     drawable.setbounds(0, 0, canvas.getwidth(), canvas.getheight());
     drawable.draw(canvas);
     return bitmap;
   } catch (outofmemoryerror e) {
     return null;
   }
  }
  private void setup() {
   if (!mready) {
     msetuppending = true;
     return;
   }
   if (mbitmap == null) {
     return;
   }
   mbitmapshader = new bitmapshader(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);
   mbitmapheight = mbitmap.getheight();
   mbitmapwidth = mbitmap.getwidth();
   mborderrect.set(0, 0, getwidth(), getheight());
   mborderradius = math.min((mborderrect.height() - mborderwidth) / 2, (mborderrect.width() - mborderwidth) / 2);
   mdrawablerect.set(mborderwidth, mborderwidth, mborderrect.width() - mborderwidth, mborderrect.height() - mborderwidth);
   mdrawableradius = math.min(mdrawablerect.height() / 2, mdrawablerect.width() / 2);
   updateshadermatrix();
   invalidate();
  }
  private void updateshadermatrix() {
   float scale;
   float dx = 0;
   float dy = 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) + mborderwidth, (int) (dy + 0.5f) + mborderwidth);
   mbitmapshader.setlocalmatrix(mshadermatrix);
  }
}