Android实现圆形图片的两种方式

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; 
 
 // 圆形边框的厚度默认值。 
 // 如果是0，则没有天蓝色渐变的边框。 
 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; 
 private final paint mflagbackgroundpaint = new paint(); 
 private final textpaint mflagtextpaint = new textpaint(); 
 private string mflagtext; 
 private boolean mshowflag = false; 
 private rect mflagtextbounds = new rect(); 
 
 shader msweepgradient = null; 
 
 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); 
 
  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.save(); 
   canvas.rotate(20, getwidth() / 2, getheight() / 2); 
   canvas.drawcircle(getwidth() / 2, getheight() / 2, mborderradius, 
     mborderpaint); 
   canvas.restore(); 
  } 
 
  if (mshowflag && mflagtext != null) { 
   canvas.drawarc(mborderrect, 40, 100, false, mflagbackgroundpaint); 
   mflagtextpaint.gettextbounds(mflagtext, 0, mflagtext.length(), 
     mflagtextbounds); 
   canvas.drawtext(mflagtext, getwidth() / 2, 
     (float) ((3 + math.cos((float) (math.pi * 5 / 18))) 
            * getheight() / 4 + mflagtextbounds.height() / 3), 
     mflagtextpaint); 
 
  } 
 
 } 
 
 @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; 
 } 
 
 /** 
  * @param borderwidth 
  *   圆形的边框厚度。 
  */ 
 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); 
 
  mflagbackgroundpaint.setcolor(color.black & 0x66ffffff); 
  mflagbackgroundpaint.setflags(textpaint.anti_alias_flag); 
 
  mflagtextpaint.setflags(textpaint.anti_alias_flag); 
  mflagtextpaint.settextalign(align.center); 
  mflagtextpaint.setcolor(color.white); 
  mflagtextpaint 
    .settextsize(getresources().getdisplaymetrics().density * 18); 
 
  msweepgradient = new sweepgradient(getwidth() / 2, getheight() / 2, 
    new int[] { color.rgb(255, 255, 255), color.rgb(1, 209, 255) }, 
    null); 
 
  mborderpaint.setshader(msweepgradient); 
 
  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); 
 } 
 
 public void setshowflag(boolean show) { 
  mshowflag = show; 
  invalidate(); 
 } 
 
 public void setflagtext(string text) { 
  mflagtext = text; 
  invalidate(); 
 } 
} 

/** 
  * 将图片剪裁为圆形 
  */ 
 public static bitmap createcircleimage(bitmap source) { 
  int length = source.getwidth() < source.getheight() ? source.getwidth() : source.getheight(); 
  paint paint = new paint(); 
  paint.setantialias(true); 
  bitmap target = bitmap.createbitmap(length, length, bitmap.config.argb_8888); 
  canvas canvas = new canvas(target); 
  canvas.drawcircle(length / 2, length / 2, length / 2, paint); 
  paint.setxfermode(new porterduffxfermode(porterduff.mode.src_in)); 
  canvas.drawbitmap(source, 0, 0, paint); 
  return target; 
 } 

//从imageview中获取bitmap 
  bitmap bm =((bitmapdrawable) ( imageview).getdrawable()).getbitmap();