android 头像球_Android使用CircleImageView实现圆形头像的方法

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

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

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

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

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">

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"

/>

注意的是要写上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);

}

}

希望与广大网友互动？？

点此进行留言吧！