Android 如何为圆角的ImageView设置图像大小

我已将带有圆角的

图像视图添加到
列表视图
。我的项目进展顺利。但并非所有的图像都是相同大小的。我的代码如下：

holder.img.setImageBitmap(createRoundedBitmap(user.getbi(),20));


private Bitmap createRoundedBitmap(Bitmap getbi, int i) {
 if (getbi == null) {
        return null;
    }    
    Rect rect = new Rect(0, 0, getbi.getWidth(), getbi.getHeight());

    // create output bitmap

    Bitmap output = Bitmap.createBitmap(getbi.getWidth(), getbi.getHeight(), Config.ARGB_8888);

    // assign canvas with output bitmap
    Canvas canvas = new Canvas(output);
    canvas.drawARGB(0,0, 0,0);

    // initialize paint
    Paint paint = new Paint();
    paint.setAntiAlias(true);

    // draw rounded rect to bitmap
    paint.setColor(0xFFFFFFFF);
    canvas.drawRoundRect(new RectF(rect), i, i, paint);

    // copy original bitmap to rounded area
    paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
    canvas.drawBitmap(getbi, rect, rect, paint);

    return output;
}

那么，我应该怎么做来修正这个位图的大小呢？
下面的链接在这里可能很有用


更改宽度和高度：

试试这个

private Bitmap createRoundedBitmap(Bitmap getbi, int i,int neededWidth,int neededHeight) {
 if (getbi == null) {
        return null;
    }    
    Rect rect = new Rect(0, 0, neededWidth, neededHeight);
    Rect bmRect = new Rect(0, 0, getbi.getWidth(), getbi.getHeight());
    // create output bitmap

    Bitmap output = Bitmap.createBitmap(neededWidth, neededHeight, Config.ARGB_8888);

    // assign canvas with output bitmap
    Canvas canvas = new Canvas(output);
    canvas.drawARGB(0,0, 0,0);

    // initialize paint
    Paint paint = new Paint();
    paint.setAntiAlias(true);

    // draw rounded rect to bitmap
    paint.setColor(0xFFFFFFFF);
    canvas.drawRoundRect(new RectF(rect), i, i, paint);

    // copy original bitmap to rounded area
    paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
    canvas.drawBitmap(getbi, bmRect , rect, paint);

    return output;
}

用法：

createRoundedBitmap（yourBitmap，5100100）；//您将得到一个100x100像素的位图

试试这种方法，希望这能帮助你解决问题。

RoundedImageView.java

public class RoundedImageView extends ImageView {

  public static final String TAG = "RoundedImageView";
  public static final int DEFAULT_RADIUS = 0;
  public static final int DEFAULT_BORDER_WIDTH = 0;
  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 int mCornerRadius = DEFAULT_RADIUS;
  private int mBorderWidth = DEFAULT_BORDER_WIDTH;
  private ColorStateList mBorderColor =
      ColorStateList.valueOf(RoundedDrawable.DEFAULT_BORDER_COLOR);
  private boolean mOval = false;
  private boolean mRoundBackground = 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);
    }

    mCornerRadius = a.getDimensionPixelSize(R.styleable.RoundedImageView_corner_radius, 360);
    mBorderWidth = a.getDimensionPixelSize(R.styleable.RoundedImageView_border_width,2);

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

    mBorderColor = a.getColorStateList(R.styleable.RoundedImageView_border_color);
    if (mBorderColor == null) {
      mBorderColor = ColorStateList.valueOf(R.color.blue);
    }

    mRoundBackground = a.getBoolean(R.styleable.RoundedImageView_round_background, false);
    mOval = a.getBoolean(R.styleable.RoundedImageView_is_oval, false);

    updateDrawableAttrs();
    updateBackgroundDrawableAttrs();

    a.recycle();
  }

  @Override
  protected void drawableStateChanged() {
    super.drawableStateChanged();
    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;
  }

  /**
   * 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) {
    if (scaleType == null) {
      throw new NullPointerException();
    }

    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();
      invalidate();
    }
  }

  @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 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());
  }

  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);
  }

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

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

  private void updateBackgroundDrawableAttrs() {
    updateAttrs(mBackgroundDrawable, true);
  }

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

    if (drawable instanceof RoundedDrawable) {
      ((RoundedDrawable) drawable)
          .setScaleType(mScaleType)
          .setCornerRadius(background && !mRoundBackground ? 0 : mCornerRadius)
          .setBorderWidth(background && !mRoundBackground ? 0 : mBorderWidth)
          .setBorderColors(mBorderColor)
          .setOval(mOval);
    } else if (drawable instanceof LayerDrawable) {
      // loop through layers to and set drawable attrs
      LayerDrawable ld = ((LayerDrawable) drawable);
      int layers = ld.getNumberOfLayers();
      for (int i = 0; i < layers; i++) {
        updateAttrs(ld.getDrawable(i), background);
      }
    }
  }

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

  public int getCornerRadius() {
    return mCornerRadius;
  }

  public void setCornerRadius(int radius) {
    if (mCornerRadius == radius) {
      return;
    }

    mCornerRadius = radius;
    updateDrawableAttrs();
    updateBackgroundDrawableAttrs();
  }

  public int getBorderWidth() {
    return mBorderWidth;
  }

  public void setBorderWidth(int width) {
    if (mBorderWidth == width) {
      return;
    }

    mBorderWidth = width;
    updateDrawableAttrs();
    updateBackgroundDrawableAttrs();
    invalidate();
  }

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

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

  public ColorStateList getBorderColors() {
    return mBorderColor;
  }

  public void setBorderColors(ColorStateList colors) {
    if (mBorderColor.equals(colors)) {
      return;
    }

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

  public boolean isOval() {
    return mOval;
  }

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

  public boolean isRoundBackground() {
    return mRoundBackground;
  }

  public void setRoundBackground(boolean roundBackground) {
    if (mRoundBackground == roundBackground) {
      return;
    }

    mRoundBackground = roundBackground;
    updateBackgroundDrawableAttrs();
    invalidate();
  }
}

public class RoundedDrawable extends Drawable {

  public static final String TAG = "RoundedDrawable";
  public static final int DEFAULT_BORDER_COLOR = Color.BLACK;

  private final RectF mBounds = new RectF();
  private final RectF mDrawableRect = new RectF();
  private final RectF mBitmapRect = new RectF();
  private final BitmapShader mBitmapShader;
  private final Paint mBitmapPaint;
  private final int mBitmapWidth;
  private final int mBitmapHeight;
  private final RectF mBorderRect = new RectF();
  private final Paint mBorderPaint;
  private final Matrix mShaderMatrix = new Matrix();

  private float mCornerRadius = 0;
  private boolean mOval = false;
  private float mBorderWidth = 0;
  private ColorStateList mBorderColor = ColorStateList.valueOf(DEFAULT_BORDER_COLOR);
  private ScaleType mScaleType = ScaleType.FIT_CENTER;

  public RoundedDrawable(Bitmap bitmap) {

    mBitmapWidth = bitmap.getWidth();
    mBitmapHeight = bitmap.getHeight();
    mBitmapRect.set(0, 0, mBitmapWidth, mBitmapHeight);

    mBitmapShader = new BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
    mBitmapShader.setLocalMatrix(mShaderMatrix);

    mBitmapPaint = new Paint();
    mBitmapPaint.setStyle(Paint.Style.FILL);
    mBitmapPaint.setAntiAlias(true);
    mBitmapPaint.setShader(mBitmapShader);

    mBorderPaint = new Paint();
    mBorderPaint.setStyle(Paint.Style.STROKE);
    mBorderPaint.setAntiAlias(true);
    mBorderPaint.setColor(mBorderColor.getColorForState(getState(), DEFAULT_BORDER_COLOR));
    mBorderPaint.setStrokeWidth(mBorderWidth);
  }

  public static RoundedDrawable fromBitmap(Bitmap bitmap) {
    if (bitmap != null) {
      return new RoundedDrawable(bitmap);
    } else {
      return null;
    }
  }

  public static Drawable fromDrawable(Drawable drawable) {
    if (drawable != null) {
      if (drawable instanceof RoundedDrawable) {
        // just return if it's already a RoundedDrawable
        return drawable;
      } else if (drawable instanceof LayerDrawable) {
        LayerDrawable ld = (LayerDrawable) drawable;
        int num = ld.getNumberOfLayers();

        // loop through layers to and change to RoundedDrawables if possible
        for (int i = 0; i < num; i++) {
          Drawable d = ld.getDrawable(i);
          ld.setDrawableByLayerId(ld.getId(i), fromDrawable(d));
        }
        return ld;
      }

      // try to get a bitmap from the drawable and
      Bitmap bm = drawableToBitmap(drawable);
      if (bm != null) {
        return new RoundedDrawable(bm);
      } else {
        Log.w(TAG, "Failed to create bitmap from drawable!");
      }
    }
    return drawable;
  }

  public static Bitmap drawableToBitmap(Drawable drawable) {
    if (drawable instanceof BitmapDrawable) {
      return ((BitmapDrawable) drawable).getBitmap();
    }

    Bitmap bitmap;
    int width = Math.max(drawable.getIntrinsicWidth(), 1);
    int height = Math.max(drawable.getIntrinsicHeight(), 1);
    try {
      bitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);
      Canvas canvas = new Canvas(bitmap);
      drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
      drawable.draw(canvas);
    } catch (Exception e) {
      e.printStackTrace();
      bitmap = null;
    }

    return bitmap;
  }

  @Override
  public boolean isStateful() {
    return mBorderColor.isStateful();
  }

  @Override
  protected boolean onStateChange(int[] state) {
    int newColor = mBorderColor.getColorForState(state, 0);
    if (mBorderPaint.getColor() != newColor) {
      mBorderPaint.setColor(newColor);
      return true;
    } else {
      return super.onStateChange(state);
    }
  }

  private void updateShaderMatrix() {
    float scale;
    float dx;
    float dy;

    switch (mScaleType) {
      case CENTER:
        mBorderRect.set(mBounds);
        mBorderRect.inset((mBorderWidth) / 2, (mBorderWidth) / 2);

        mShaderMatrix.set(null);
        mShaderMatrix.setTranslate((int) ((mBorderRect.width() - mBitmapWidth) * 0.5f + 0.5f),
            (int) ((mBorderRect.height() - mBitmapHeight) * 0.5f + 0.5f));
        break;

      case CENTER_CROP:
        mBorderRect.set(mBounds);
        mBorderRect.inset((mBorderWidth) / 2, (mBorderWidth) / 2);

        mShaderMatrix.set(null);

        dx = 0;
        dy = 0;

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

        mShaderMatrix.setScale(scale, scale);
        mShaderMatrix.postTranslate((int) (dx + 0.5f) + mBorderWidth,
            (int) (dy + 0.5f) + mBorderWidth);
        break;

      case CENTER_INSIDE:
        mShaderMatrix.set(null);

        if (mBitmapWidth <= mBounds.width() && mBitmapHeight <= mBounds.height()) {
          scale = 1.0f;
        } else {
          scale = Math.min(mBounds.width() / (float) mBitmapWidth,
              mBounds.height() / (float) mBitmapHeight);
        }

        dx = (int) ((mBounds.width() - mBitmapWidth * scale) * 0.5f + 0.5f);
        dy = (int) ((mBounds.height() - mBitmapHeight * scale) * 0.5f + 0.5f);

        mShaderMatrix.setScale(scale, scale);
        mShaderMatrix.postTranslate(dx, dy);

        mBorderRect.set(mBitmapRect);
        mShaderMatrix.mapRect(mBorderRect);
        mBorderRect.inset((mBorderWidth) / 2, (mBorderWidth) / 2);
        mShaderMatrix.setRectToRect(mBitmapRect, mBorderRect, Matrix.ScaleToFit.FILL);
        break;

      default:
      case FIT_CENTER:
        mBorderRect.set(mBitmapRect);
        mShaderMatrix.setRectToRect(mBitmapRect, mBounds, Matrix.ScaleToFit.CENTER);
        mShaderMatrix.mapRect(mBorderRect);
        mBorderRect.inset((mBorderWidth) / 2, (mBorderWidth) / 2);
        mShaderMatrix.setRectToRect(mBitmapRect, mBorderRect, Matrix.ScaleToFit.FILL);
        break;

      case FIT_END:
        mBorderRect.set(mBitmapRect);
        mShaderMatrix.setRectToRect(mBitmapRect, mBounds, Matrix.ScaleToFit.END);
        mShaderMatrix.mapRect(mBorderRect);
        mBorderRect.inset((mBorderWidth) / 2, (mBorderWidth) / 2);
        mShaderMatrix.setRectToRect(mBitmapRect, mBorderRect, Matrix.ScaleToFit.FILL);
        break;

      case FIT_START:
        mBorderRect.set(mBitmapRect);
        mShaderMatrix.setRectToRect(mBitmapRect, mBounds, Matrix.ScaleToFit.START);
        mShaderMatrix.mapRect(mBorderRect);
        mBorderRect.inset((mBorderWidth) / 2, (mBorderWidth) / 2);
        mShaderMatrix.setRectToRect(mBitmapRect, mBorderRect, Matrix.ScaleToFit.FILL);
        break;

      case FIT_XY:
        mBorderRect.set(mBounds);
        mBorderRect.inset((mBorderWidth) / 2, (mBorderWidth) / 2);
        mShaderMatrix.set(null);
        mShaderMatrix.setRectToRect(mBitmapRect, mBorderRect, Matrix.ScaleToFit.FILL);
        break;
    }

    mDrawableRect.set(mBorderRect);
    mBitmapShader.setLocalMatrix(mShaderMatrix);
  }

  @Override
  protected void onBoundsChange(Rect bounds) {
    super.onBoundsChange(bounds);

    mBounds.set(bounds);

    updateShaderMatrix();
  }

  @Override
  public void draw(Canvas canvas) {

    if (mOval) {
      if (mBorderWidth > 0) {
        canvas.drawOval(mDrawableRect, mBitmapPaint);
        canvas.drawOval(mBorderRect, mBorderPaint);
      } else {
        canvas.drawOval(mDrawableRect, mBitmapPaint);
      }
    } else {
      if (mBorderWidth > 0) {
        canvas.drawRoundRect(mDrawableRect, Math.max(mCornerRadius, 0),
            Math.max(mCornerRadius, 0), mBitmapPaint);
        canvas.drawRoundRect(mBorderRect, mCornerRadius, mCornerRadius, mBorderPaint);
      } else {
        canvas.drawRoundRect(mDrawableRect, mCornerRadius, mCornerRadius, mBitmapPaint);
      }
    }
  }

  @Override
  public int getOpacity() {
    return PixelFormat.TRANSLUCENT;
  }

  @Override
  public void setAlpha(int alpha) {
    mBitmapPaint.setAlpha(alpha);
    invalidateSelf();
  }

  @Override
  public void setColorFilter(ColorFilter cf) {
    mBitmapPaint.setColorFilter(cf);
    invalidateSelf();
  }

  @Override public void setDither(boolean dither) {
    mBitmapPaint.setDither(dither);
    invalidateSelf();
  }

  @Override public void setFilterBitmap(boolean filter) {
    mBitmapPaint.setFilterBitmap(filter);
    invalidateSelf();
  }

  @Override
  public int getIntrinsicWidth() {
    return mBitmapWidth;
  }

  @Override
  public int getIntrinsicHeight() {
    return mBitmapHeight;
  }

  public float getCornerRadius() {
    return mCornerRadius;
  }

  public RoundedDrawable setCornerRadius(float radius) {
    mCornerRadius = radius;
    return this;
  }

  public float getBorderWidth() {
    return mBorderWidth;
  }

  public RoundedDrawable setBorderWidth(int width) {
    mBorderWidth = width;
    mBorderPaint.setStrokeWidth(mBorderWidth);
    return this;
  }

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

  public RoundedDrawable setBorderColor(int color) {
    return setBorderColors(ColorStateList.valueOf(color));
  }

  public ColorStateList getBorderColors() {
    return mBorderColor;
  }

  public RoundedDrawable setBorderColors(ColorStateList colors) {
    mBorderColor = colors != null ? colors : ColorStateList.valueOf(0);
    mBorderPaint.setColor(mBorderColor.getColorForState(getState(), DEFAULT_BORDER_COLOR));
    return this;
  }

  public boolean isOval() {
    return mOval;
  }

  public RoundedDrawable setOval(boolean oval) {
    mOval = oval;
    return this;
  }

  public ScaleType getScaleType() {
    return mScaleType;
  }

  public RoundedDrawable setScaleType(ScaleType scaleType) {
    if (scaleType == null) {
      scaleType = ScaleType.FIT_XY;
    }
    if (mScaleType != scaleType) {
      mScaleType = scaleType;
      updateShaderMatrix();
    }
    return this;
  }

  public Bitmap toBitmap() {
    return drawableToBitmap(this);
  }
}

public类RoundedImageView扩展了ImageView{
公共静态最终字符串TAG=“RoundedImageView”；
公共静态最终int默认_半径=0；
公共静态final int DEFAULT_BORDER_WIDTH=0；
私有静态最终ScaleType[]缩放类型={
ScaleType.MATRIX，
ScaleType.FIT_XY，
ScaleType.FIT\u开始，
ScaleType.FIT_中心，
ScaleType.FIT\u END，
ScaleType.CENTER，
ScaleType.CENTER\u作物，
ScaleType.CENTER\u内部
};
private int mCornerRadius=默认半径；
private int mBorderWidth=默认边界宽度；
私有颜色状态列表mBorderColor=
ColorStateList.valueOf（RoundedDrawable.DEFAULT\u BORDER\u COLOR）；
私有布尔mOval=false；
私有布尔值mRoundBackground=false；
私人国际资源；
私人可提取；
私人可提取的MBackgrounddraw；
私有ScaleType mScaleType；
public RoundedImageView（上下文）{
超级（上下文）；
}
public RoundedImageView（上下文、属性集属性）{
这（上下文，属性，0）；
}
public RoundedImageView（上下文、属性集属性、int-defStyle）{
超级（上下文、属性、定义样式）；
TypedArray a=上下文。获取样式属性（attrs，R.styleable.RoundedImageView，defStyle，0）；
int index=a.getInt（R.styleable.RoundedImageView\u android\u scaleType，1）；
如果（索引>=0）{
设置刻度类型（刻度类型[索引]）；
}否则{
//默认缩放类型，以适应\u中心
setScaleType（ScaleType.FIT_CENTER）；
}
mCornerRadius=a.getDimensionPixelSize（R.styleable.RoundedImageView\u corner\u radius，360）；
mBorderWidth=a.getDimensionPixelSize（R.styleable.RoundeImage视图\边框\宽度，2）；
//不允许半径和边界为负值
if（mCornerRadius<0）{
mCornerRadius=默认半径；
}
如果（mBorderWidth<0）{
mBorderWidth=默认边界宽度；
}
mBorderColor=a.getColorStateList（R.styleable.RoundedImageView\u border\u color）；
如果（mBorderColor==null）{
mBorderColor=ColorStateList.valueOf（R.color.blue）；
}
mRoundBackground=a.getBoolean（R.styleable.RoundedImageView\u round\u background，false）；
mOval=a.getBoolean（R.styleable.RoundedImageView_为椭圆形，false）；
updateDrawableAttrs（）；
updateBackgroundDrawableAttrs（）；
a、 回收（）；
}
@凌驾
受保护的无效drawableStateChanged（）{
super.drawableStateChanged（）；
使无效（）；
}
/**
*返回此ImageView正在使用的当前比例类型。
*
*@attr ref android.R.styleable#ImageView_scaleType
*@see android.widget.ImageView.ScaleType
*/
@凌驾
公共ScaleType getScaleType（）{
返回mScaleType；
}
/**
*控制如何调整图像大小或移动图像以匹配大小
*此图像视图的一部分。
*
*@param scaleType指定所需的缩放模式。
*@attr ref android.R.styleable#ImageView_scaleType
*/
@凌驾
public void setScaleType（ScaleType ScaleType）{
if（scaleType==null）{
抛出新的NullPointerException（）；
}
if（mScaleType！=scaleType）{
mScaleType=scaleType；
开关（scaleType）{
案例中心：
案例中心\u裁剪：
案件中心(内部):
机箱安装中心：
机箱安装和启动：
外壳安装端：
箱体配合：
super.setScaleType（ScaleType.FIT_XY）；
打破
违约：
super.setScaleType（scaleType）；
打破
}
updateDrawableAttrs（）；
updateBackgroundDrawableAttrs（）；
使无效（）；
}
}
@凌驾
公共void setImageDrawable（可提取可提取）{
mResource=0；
mDrawable=舍入可绘制。fromDrawable（可绘制）；
updateDrawableAttrs（）；
super.setImageDrawable（MDraawable）；
}
@凌驾
公共void setImageBitmap（位图bm）{
mResource=0；
mDrawable=RoundedDrawable.fromBitmap（bm）；
updateDrawableAttrs（）；
super.setImageDrawable（MDraawable）；
}
@凌驾
公共void setImageResource（int resId）{
如果（mResource！=剩余）{
mResource=resId；
mDrawable=resolveResource（）；
updateDrawableAttrs（）；
super.setImageDrawable（MDraawable）；
}
}
@重写公共无效setImageURI（Uri）{
super.setImageURI（uri）；
setImageDrawable（getDrawable（））；
}
私有可提取可解析资源（）{
Resources rsrc=getResources（）；
如果（rsrc==null）{
返回null；
}
可提取d=null；
如果（mResource！=0）{
试一试{
d=rsrc.getDrawable（mResource）；
}捕获（例外e）{
Log.w（标记“找不到资源：”+mResource，e）；
//不要再试。
mResource=0；
}
}
返回四舍五入可绘制。从可绘制（d）；
}
@凌驾
公共空间背景（可绘制背景）{
可缩进（背景）；
}
私有void updateDrawableAttrs（）{
updateAttrs（可绘制，错误）；
}
私有void updateBackgroundDrawableAttrs（）{
updateAttrs（mBackgroundDrawable，true）；
}
私有void updateAttrs（可绘制、可绘制、布尔背景）{
if（可绘制==null）{
返回；
}
if（可绘制实例的圆形可绘制）{
（（圆形可绘制）可绘制）
.setScaleType（mScaleType）
.setCornerRadius（背景和！mRoundBackground？0:mCornerRadius）
<resources>
    <declare-styleable name="RoundedImageView">
        <attr name="corner_radius" format="dimension" />
        <attr name="border_width" format="dimension" />
        <attr name="border_color" format="color" />
        <attr name="round_background" format="boolean" />
        <attr name="is_oval" format="boolean" />
        <attr name="android:scaleType" />
    </declare-styleable>
    <declare-styleable name="CircleLayout">
        <attr name="innerRadius" format="dimension" />
        <attr name="sliceDivider" format="reference|color" />
        <attr name="innerCircle" format="reference|color" />
        <attr name="angleOffset" format="float" />
        <attr name="angleRange" format="float" />
        <attr name="layoutMode">
            <enum name="normal" value="1" />
            <enum name="pie" value="2" />
        </attr>
        <attr name="dividerWidth" format="dimension" />
    </declare-styleable>
</resources>

<YourPackageName.RoundedImageView
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:scaleType="centerCrop"/>