Как сделать круговое изображение на андроид

Question

Я хочу сделать круговую изображение как этот один

Вот код, помогите пожалуйста, я попытался следующий код, но он не работает нормально для меня. Спасибо

код: .....

private Bitmap decodeFile(File f){ 
    try { 
     //decode image size 
     BitmapFactory.Options o = new BitmapFactory.Options(); 
     o.inJustDecodeBounds = true; 
     BitmapFactory.decodeStream(new FileInputStream(f),null,o); 

     //Find the correct scale value. It should be the power of 2. 
     final int REQUIRED_SIZE=80; 
     int width_tmp=o.outWidth, height_tmp=o.outHeight; 
     int scale=1; 
     while(true){ 
      if(width_tmp/2<REQUIRED_SIZE || height_tmp/2<REQUIRED_SIZE) 
       break; 
      width_tmp/=2; 
      height_tmp/=2; 
      scale*=2; 
     } 

     //decode with inSampleSize 
     BitmapFactory.Options o2 = new BitmapFactory.Options(); 
     o2.inSampleSize=scale; 
     return BitmapFactory.decodeStream(new FileInputStream(f), null, o2); 
    } catch (FileNotFoundException e) {} 
    return null; 
} 

Answer 1

Попробуйте этот путь, надеюсь, это поможет вам решить вашу проблему

Простой и удобный ... вы должны использовать этот метод, чтобы сделать форму изображения круга,

public static Bitmap circleShape(Bitmap preview_bitmap) { 

    Bitmap circleBitmap = Bitmap.createBitmap(preview_bitmap.getWidth(), 
      preview_bitmap.getHeight(), Bitmap.Config.ARGB_8888); 
    BitmapShader shader = new BitmapShader(preview_bitmap, TileMode.CLAMP, 
      TileMode.CLAMP); 
    Paint paint = new Paint(); 
    paint.setShader(shader); 
    Canvas c = new Canvas(circleBitmap); 
    c.drawCircle(
      preview_bitmap.getWidth()/2, 
      preview_bitmap.getHeight()/2, 
      Math.min(preview_bitmap.getWidth()/2, 
        preview_bitmap.getHeight()/2), paint); 
    return circleBitmap; 

} 

Всякий раз, когда вам нужно сделать круг растровым затем использовать

Bitmap uImage = circleShape(uImage); 

    ivAddPhoto.setImageBitmap(uImage); 

Answer 2

Вы можете использовать настраиваемое представление изображения, я использовал его с Q-municate App

@SuppressWarnings("UnusedDeclaration") 
public class RoundedImageView extends ImageView { 

    public static final String TAG = "RoundedImageView"; 
    public static final float DEFAULT_RADIUS = 0f; 
    private float cornerRadius = DEFAULT_RADIUS; 
    public static final float DEFAULT_BORDER_WIDTH = 0f; 
    private float borderWidth = DEFAULT_BORDER_WIDTH; 
    private static final ScaleType[] SCALE_TYPES = {ScaleType.MATRIX, ScaleType.FIT_XY, ScaleType.FIT_START, ScaleType.FIT_CENTER, ScaleType.FIT_END, ScaleType.CENTER, ScaleType.CENTER_CROP, ScaleType.CENTER_INSIDE}; 
    private ColorStateList borderColor = ColorStateList.valueOf(RoundedDrawable.DEFAULT_BORDER_COLOR); 
    private boolean isOval = false; 
    private boolean mutateBackground = false; 

    private int mResource; 
    private Drawable mDrawable; 
    private Drawable mBackgroundDrawable; 

    private ScaleType mScaleType; 

    public RoundedImageView(Context context) { 
     super(context); 
    } 

    public RoundedImageView(Context context, AttributeSet attrs) { 
     this(context, attrs, 0); 
    } 

    public RoundedImageView(Context context, AttributeSet attrs, int defStyle) { 
     super(context, attrs, defStyle); 

     TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.RoundedImageView, defStyle, 0); 

     int index = a.getInt(R.styleable.RoundedImageView_android_scaleType, -1); 
     if (index >= 0) { 
      setScaleType(SCALE_TYPES[index]); 
     } else { 
      // default scaletype to FIT_CENTER 
      setScaleType(ScaleType.FIT_CENTER); 
     } 

     cornerRadius = a.getDimensionPixelSize(R.styleable.RoundedImageView_corner_radius, -1); 
     borderWidth = a.getDimensionPixelSize(R.styleable.RoundedImageView_border_width, -1); 

     // don't allow negative values for radius and border 
     if (cornerRadius < 0) { 
      cornerRadius = DEFAULT_RADIUS; 
     } 
     if (borderWidth < 0) { 
      borderWidth = DEFAULT_BORDER_WIDTH; 
     } 

     borderColor = a.getColorStateList(R.styleable.RoundedImageView_border_color); 
     if (borderColor == null) { 
      borderColor = ColorStateList.valueOf(RoundedDrawable.DEFAULT_BORDER_COLOR); 
     } 

     mutateBackground = a.getBoolean(R.styleable.RoundedImageView_mutate_background, false); 
     isOval = a.getBoolean(R.styleable.RoundedImageView_oval, false); 

     updateDrawableAttrs(); 
     updateBackgroundDrawableAttrs(true); 

     a.recycle(); 
    } 

    @Override 
    public void setImageResource(int resId) { 
     if (mResource != resId) { 
      mResource = resId; 
      mDrawable = resolveResource(); 
      updateDrawableAttrs(); 
      super.setImageDrawable(mDrawable); 
     } 
    } 

    @Override 
    public void setImageURI(Uri uri) { 
     super.setImageURI(uri); 
     setImageDrawable(getDrawable()); 
    } 

    @Override 
    public void setImageDrawable(Drawable drawable) { 
     mResource = 0; 
     mDrawable = RoundedDrawable.fromDrawable(drawable); 
     updateDrawableAttrs(); 
     super.setImageDrawable(mDrawable); 
    } 

    @Override 
    public void setImageBitmap(Bitmap bm) { 
     mResource = 0; 
     mDrawable = RoundedDrawable.fromBitmap(bm); 
     updateDrawableAttrs(); 
     super.setImageDrawable(mDrawable); 
    } 

    @Override 
    public void setBackground(Drawable background) { 
     setBackgroundDrawable(background); 
    } 

    @Override 
    @Deprecated 
    public void setBackgroundDrawable(Drawable background) { 
     mBackgroundDrawable = background; 
     updateBackgroundDrawableAttrs(true); 
     super.setBackgroundDrawable(mBackgroundDrawable); 
    } 

    public float getCornerRadius() { 
     return cornerRadius; 
    } 

    @Override 
    protected void drawableStateChanged() { 
     super.drawableStateChanged(); 
     invalidate(); 
    } 

    public void setCornerRadius(float radius) { 
     if (cornerRadius == radius) { 
      return; 
     } 

     cornerRadius = radius; 
     updateDrawableAttrs(); 
     updateBackgroundDrawableAttrs(false); 
    } 

    public void setCornerRadius(int resId) { 
     setCornerRadius(getResources().getDimension(resId)); 
    } 

    public float getBorderWidth() { 
     return borderWidth; 
    } 

    public void setBorderWidth(float width) { 
     if (borderWidth == width) { 
      return; 
     } 

     borderWidth = width; 
     updateDrawableAttrs(); 
     updateBackgroundDrawableAttrs(false); 
     invalidate(); 
    } 

    public void setBorderWidth(int resId) { 
     setBorderWidth(getResources().getDimension(resId)); 
    } 

    public int getBorderColor() { 
     return borderColor.getDefaultColor(); 
    } 

    public void setBorderColor(ColorStateList colors) { 
     if (borderColor.equals(colors)) { 
      return; 
     } 

     borderColor = (colors != null) ? colors : ColorStateList.valueOf(
       RoundedDrawable.DEFAULT_BORDER_COLOR); 
     updateDrawableAttrs(); 
     updateBackgroundDrawableAttrs(false); 
     if (borderWidth > 0) { 
      invalidate(); 
     } 
    } 

    /** 
    * Return the current scale type in use by this ImageView. 
    * 
    * @attr ref android.R.styleable#ImageView_scaleType 
    * @see android.widget.ImageView.ScaleType 
    */ 
    @Override 
    public ScaleType getScaleType() { 
     return mScaleType; 
    } 

    public void setBorderColor(int color) { 
     setBorderColor(ColorStateList.valueOf(color)); 
    } 

    public ColorStateList getBorderColors() { 
     return borderColor; 
    } 

    public boolean isOval() { 
     return isOval; 
    } 

    public void setOval(boolean oval) { 
     isOval = oval; 
     updateDrawableAttrs(); 
     updateBackgroundDrawableAttrs(false); 
     invalidate(); 
    } 

    public boolean isMutateBackground() { 
     return mutateBackground; 
    } 

    public void setMutateBackground(boolean mutate) { 
     if (mutateBackground == mutate) { 
      return; 
     } 

     mutateBackground = mutate; 
     updateBackgroundDrawableAttrs(true); 
     invalidate(); 
    } 

    private Drawable resolveResource() { 
     Resources rsrc = getResources(); 
     if (rsrc == null) { 
      return null; 
     } 

     Drawable d = null; 

     if (mResource != 0) { 
      try { 
       d = rsrc.getDrawable(mResource); 
      } catch (Exception e) { 
       Log.w(TAG, "Unable to find resource: " + mResource, e); 
       // Don't try again. 
       mResource = 0; 
      } 
     } 
     return RoundedDrawable.fromDrawable(d); 
    } 

    /** 
    * Controls how the image should be resized or moved to match the size 
    * of this ImageView. 
    * 
    * @param scaleType The desired scaling mode. 
    * @attr ref android.R.styleable#ImageView_scaleType 
    */ 
    @Override 
    public void setScaleType(ScaleType scaleType) { 
     assert scaleType != null; 

     if (mScaleType != scaleType) { 
      mScaleType = scaleType; 

      switch (scaleType) { 
       case CENTER: 
       case CENTER_CROP: 
       case CENTER_INSIDE: 
       case FIT_CENTER: 
       case FIT_START: 
       case FIT_END: 
       case FIT_XY: 
        super.setScaleType(ScaleType.FIT_XY); 
        break; 
       default: 
        super.setScaleType(scaleType); 
        break; 
      } 

      updateDrawableAttrs(); 
      updateBackgroundDrawableAttrs(false); 
      invalidate(); 
     } 
    } 

    private void updateDrawableAttrs() { 
     updateAttrs(mDrawable); 
    } 

    private void updateBackgroundDrawableAttrs(boolean convert) { 
     if (mutateBackground) { 
      if (convert) { 
       mBackgroundDrawable = RoundedDrawable.fromDrawable(mBackgroundDrawable); 
      } 
      updateAttrs(mBackgroundDrawable); 
     } 
    } 

    private void updateAttrs(Drawable drawable) { 
     if (drawable == null) { 
      return; 
     } 

     if (drawable instanceof RoundedDrawable) { 
      ((RoundedDrawable) drawable).setScaleType(mScaleType).setCornerRadius(cornerRadius) 
        .setBorderWidth(borderWidth).setBorderColor(borderColor).setOval(isOval); 
     } else if (drawable instanceof LayerDrawable) { 
      // loop through layers to and set drawable attrs 
      LayerDrawable ld = ((LayerDrawable) drawable); 
      for (int i = 0, layers = ld.getNumberOfLayers(); i < layers; i++) { 
       updateAttrs(ld.getDrawable(i)); 
      } 
     } 
    } 
} 

сделать его работу используйте следующий код в java-файле после получения изображения из xml:

imageView.setOval(true); 

Answer 3

Существует теперь родное решение для этого в новой версии библиотеки поддержки называется RoundedBitmapDrawable