Android 使ImageView适合CardView的宽度

我有一个圆角的

cardwiew

，我想在顶部有一个

ImageView

，如下面的材料设计指南示例所示

<android.support.v7.widget.CardView xmlns:card_view="http://schemas.android.com/apk/res-auto"
     android:id="@+id/card_view"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
     card_view:cardCornerRadius="4dp">

     <!-- ... --> 
 </android.support.v7.widget.CardView>

如果我将

card\u view:cardCornerRadius

设置为

0dp

，则

ImageView

会像我希望的那样适合卡

然而，国家规定卡片应该有圆角，而不是直角

我遇到的问题是，当我将

card\u视图：cardCornerRadius

设置为

0dp

以外的值时，例如

4dp

，则会发生以下情况：

可以看出，

ImageView

不适合

CardView

---

我的问题是，当它有圆角时，如何使这个

ImageView

适合

CardView

的布局。

在

drawable

文件夹中制作一个

bck\u rounded.xml

。给它一个与卡片视图相同的半径

<?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android" >
        <corners android:radius="4dp" />
    </shape>

在imageView中应用：

android:background=“@drawable/bck\u rounded”

编辑2015/09/29

增加了对选定拐角圆角的支持

也可以使用makeramen RoundeImage视图， 并移除CardView中的自动填充，以便在棒棒糖前使用

yourCardView.setPreventCornerOverlap（false）

---

然后设置显示cardview阴影所需的填充

您需要做两件事：

1） 在您的CardView上调用

setPreventCornerOverlap（false）

2） 将四舍五入的图像视图放入CardView内部

关于将imageview四舍五入，我遇到了同样的问题，因此我制作了一个库，您可以在每个角上设置不同的半径。有一个很好的库（vinc3m1的RoundedImageView）支持ImageView上的圆角，但它只支持每个角上相同的半径。但我希望它只在左上角和右上角圆滑

最后我得到了下面我想要的结果

我通过将

RoundedImageView

放在

CardView

中来实现这一点。您还需要设置相应的

CardView

属性

如果图像大小（宽度）与

ImageView

宽度固定，您只需将

ImageView

属性更改为：

android:scaleType="fitXY"

就是。没有额外的图像圆角，没有繁忙的工作。除此之外，它还可以提高应用程序的性能

---

注意：我的建议可能不适用于大尺寸的小图像

ImageView

我解决了设置问题
1）

app:cardUseCompatding=“false”

2） 设置圆形

imageView

背景

<shape xmlns:android="http://schemas.android.com/apk/res/android" >
    <corners android:radius="4dp" />
</shape>

---

您必须自定义图像视图

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.RectF;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;

public class RoundedImageView extends android.support.v7.widget.AppCompatImageView {
private Paint mPaint;
private Path mPath;
private Bitmap mBitmap;
private Matrix mMatrix;
private int mRadius = convertDpToPixel(10);
private int mWidth;
private int mHeight;
private Drawable mDrawable;

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

public RoundedImageView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init();
}

public RoundedImageView(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    init();
}

private void init() {
    mPaint = new Paint();
    mPaint.setColor(Color.WHITE);

    mPath = new Path();
}

public int convertDpToPixel(int dp) {
    DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
    return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, displayMetrics);
}

@Override
public void setImageDrawable(Drawable drawable) {
    mDrawable = drawable;
    if (drawable == null) {
        return;
    }
    mBitmap = drawableToBitmap(drawable);
    int bDIWidth = mBitmap.getWidth();
    int bDIHeight = mBitmap.getHeight();
    //Fit to screen.
    float scale;
    if ((mHeight / (float) bDIHeight) >= (mWidth / (float) bDIWidth)) {
        scale = mHeight / (float) bDIHeight;
    } else {
        scale = mWidth / (float) bDIWidth;
    }
    float borderLeft = (mWidth - (bDIWidth * scale)) / 2;
    float borderTop = (mHeight - (bDIHeight * scale)) / 2;
    mMatrix = getImageMatrix();
    RectF drawableRect = new RectF(0, 0, bDIWidth, bDIHeight);
    RectF viewRect = new RectF(borderLeft, borderTop, (bDIWidth * scale) + borderLeft, (bDIHeight * scale) + borderTop);
    mMatrix.setRectToRect(drawableRect, viewRect, Matrix.ScaleToFit.CENTER);
    invalidate();
}

private Bitmap drawableToBitmap(Drawable drawable) {
    Bitmap bitmap;
    if (drawable instanceof BitmapDrawable) {
        BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
        if (bitmapDrawable.getBitmap() != null) {
            return bitmapDrawable.getBitmap();
        }
    }
    if (drawable.getIntrinsicWidth() <= 0 || drawable.getIntrinsicHeight() <= 0) {
        bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888); // Single color bitmap will be created of 1x1 pixel
    } else {
        bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
    }
    Canvas canvas = new Canvas(bitmap);
    drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
    drawable.draw(canvas);
    return bitmap;
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    mWidth = MeasureSpec.getSize(widthMeasureSpec);
    mHeight = MeasureSpec.getSize(heightMeasureSpec);
    if ((mDrawable != null) && (mHeight > 0) && (mWidth > 0)) {
        setImageDrawable(mDrawable);
    }
}

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    if (mBitmap == null) {
        return;
    }
    canvas.drawColor(Color.TRANSPARENT);
    mPath.reset();
    mPath.moveTo(0, mRadius);
    mPath.lineTo(0, canvas.getHeight());
    mPath.lineTo(canvas.getWidth(), canvas.getHeight());
    mPath.lineTo(canvas.getWidth(), mRadius);
    mPath.quadTo(canvas.getWidth(), 0, canvas.getWidth() - mRadius, 0);
    mPath.lineTo(mRadius, 0);
    mPath.quadTo(0, 0, 0, mRadius);
    canvas.drawPath(mPath, mPaint);
    canvas.clipPath(mPath);
    canvas.drawBitmap(mBitmap, mMatrix, mPaint);
}
}

导入android.content.Context；
导入android.graphics.Bitmap；
导入android.graphics.Canvas；
导入android.graphics.Color；
导入android.graphics.Matrix；
导入android.graphics.Paint；
导入android.graphics.Path；
导入android.graphics.RectF；
导入android.graphics.drawable.BitmapDrawable；
导入android.graphics.drawable.drawable；
导入android.util.AttributeSet；
公共类RoundedImageView扩展了android.support.v7.widget.AppCompatImageView{
私人油漆；
专用路径mPath；
私有位图mBitmap；
私有矩阵矩阵；
private int mRadius=convertDpToPixel（10）；
私人英特姆维兹；
私营机构；
私人可提取；
public RoundedImageView（上下文）{
超级（上下文）；
init（）；
}
public RoundedImageView（上下文、属性集属性）{
超级（上下文，attrs）；
init（）；
}
public RoundedImageView（上下文上下文、属性集属性、int defStyleAttr）{
super（上下文、attrs、defStyleAttr）；
init（）；
}
私有void init（）{
mPaint=新油漆（）；
mPaint.setColor（Color.WHITE）；
mPath=新路径（）；
}
公共int convertDpToPixel（int-dp）{
DisplayMetrics DisplayMetrics=Resources.getSystem（）.getDisplayMetrics（）；
返回（int）TypedValue.applyDimension（TypedValue.COMPLEX\u UNIT\u DIP，dp，displayMetrics）；
}
@凌驾
公共void setImageDrawable（可提取可提取）{
mDrawable=可绘制；
if（可绘制==null）{
返回；
}
mBitmap=drawableToBitmap（可绘制）；
int bDIWidth=mBitmap.getWidth（）；
int bDIHeight=mBitmap.getHeight（）；
//适合屏幕。
浮标；
如果（（mHeight/（float）bDIHeight）>=（mWidth/（float）bDIWidth））{
刻度=mHweight/（浮动）bDiHweight；
}否则{
刻度=mWidth/（浮动）bDIWidth；
}
浮动边框左=（mWidth-（bDIWidth*比例））/2；
浮动边界顶部=（mHweight-（bDiHweight*比例））/2；
mMatrix=getImageMatrix（）；
RectF drawableRect=新的RectF（0，0，bDIWidth，bDIHeight）；
RectF viewRect=新的RectF（borderLeft，borderTop，（BDI宽度*比例）+borderLeft，（BDI高度*比例）+borderTop）；
mMatrix.setRectRect（drawableRect、viewRect、Matrix.ScaleToFit.CENTER）；
使无效（）；
}
私有位图drawableToBitmap（可绘制可绘制）{
位图；
if（BitmapDrawable的可绘制实例）{
BitmapDrawable BitmapDrawable=（BitmapDrawable）drawable；
if（bitmapDrawable.getBitmap（）！=null）{
返回bitmapDrawable.getBitmap（）；
}
}
if（drawable.getIntrinsicWidth（）0））{
setImageDrawable（MDraawable）；
}
}
@凌驾
受保护的void onDraw（画布）{
super.onDraw（帆布）；
if（mBitmap==null）{
返回；
}
画布。drawColor（颜色。透明）；
mPath.reset（）；
移动到（0，mRadius）；
lineTo（0，canvas.getHeight（））；
lineTo（canvas.getWidth（），canvas.getHeight（））；
mPath.lineTo（canvas.getWidth（），mRadius）；
mPath.quadTo（canvas.getWidth（），0，canvas.getWidth（）-mRadius，0）；
mPath.lineTo（mRadius，0）；
四分位数（0，0，0，mRadius）；
帆布
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.RectF;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;

public class RoundedImageView extends android.support.v7.widget.AppCompatImageView {
private Paint mPaint;
private Path mPath;
private Bitmap mBitmap;
private Matrix mMatrix;
private int mRadius = convertDpToPixel(10);
private int mWidth;
private int mHeight;
private Drawable mDrawable;

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

public RoundedImageView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init();
}

public RoundedImageView(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    init();
}

private void init() {
    mPaint = new Paint();
    mPaint.setColor(Color.WHITE);

    mPath = new Path();
}

public int convertDpToPixel(int dp) {
    DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
    return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, displayMetrics);
}

@Override
public void setImageDrawable(Drawable drawable) {
    mDrawable = drawable;
    if (drawable == null) {
        return;
    }
    mBitmap = drawableToBitmap(drawable);
    int bDIWidth = mBitmap.getWidth();
    int bDIHeight = mBitmap.getHeight();
    //Fit to screen.
    float scale;
    if ((mHeight / (float) bDIHeight) >= (mWidth / (float) bDIWidth)) {
        scale = mHeight / (float) bDIHeight;
    } else {
        scale = mWidth / (float) bDIWidth;
    }
    float borderLeft = (mWidth - (bDIWidth * scale)) / 2;
    float borderTop = (mHeight - (bDIHeight * scale)) / 2;
    mMatrix = getImageMatrix();
    RectF drawableRect = new RectF(0, 0, bDIWidth, bDIHeight);
    RectF viewRect = new RectF(borderLeft, borderTop, (bDIWidth * scale) + borderLeft, (bDIHeight * scale) + borderTop);
    mMatrix.setRectToRect(drawableRect, viewRect, Matrix.ScaleToFit.CENTER);
    invalidate();
}

private Bitmap drawableToBitmap(Drawable drawable) {
    Bitmap bitmap;
    if (drawable instanceof BitmapDrawable) {
        BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
        if (bitmapDrawable.getBitmap() != null) {
            return bitmapDrawable.getBitmap();
        }
    }
    if (drawable.getIntrinsicWidth() <= 0 || drawable.getIntrinsicHeight() <= 0) {
        bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888); // Single color bitmap will be created of 1x1 pixel
    } else {
        bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
    }
    Canvas canvas = new Canvas(bitmap);
    drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
    drawable.draw(canvas);
    return bitmap;
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    mWidth = MeasureSpec.getSize(widthMeasureSpec);
    mHeight = MeasureSpec.getSize(heightMeasureSpec);
    if ((mDrawable != null) && (mHeight > 0) && (mWidth > 0)) {
        setImageDrawable(mDrawable);
    }
}

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    if (mBitmap == null) {
        return;
    }
    canvas.drawColor(Color.TRANSPARENT);
    mPath.reset();
    mPath.moveTo(0, mRadius);
    mPath.lineTo(0, canvas.getHeight());
    mPath.lineTo(canvas.getWidth(), canvas.getHeight());
    mPath.lineTo(canvas.getWidth(), mRadius);
    mPath.quadTo(canvas.getWidth(), 0, canvas.getWidth() - mRadius, 0);
    mPath.lineTo(mRadius, 0);
    mPath.quadTo(0, 0, 0, mRadius);
    canvas.drawPath(mPath, mPaint);
    canvas.clipPath(mPath);
    canvas.drawBitmap(mBitmap, mMatrix, mPaint);
}
}

<com.example.widget.RoundedImageViewmageView
            android:id="@+id/ivProductImg"
            android:layout_width="match_parent"
            android:layout_height="150dp"
            android:scaleType="fitXY"
            />

    android.support.v7.widget.CardView
            android:layout_width="match_parent"
            android:layout_height="160dp"
            android:layout_marginStart="16dp"
            android:layout_marginLeft="16dp"
            android:layout_marginTop="8dp"
            android:layout_marginEnd="16dp"
            android:layout_marginRight="16dp"
            app:cardCornerRadius="8dp"
            android:elevation="10dp"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toBottomOf="@+id/textView">

            <ImageView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:src="@drawable/kmp_warna1"
                android:scaleType="centerCrop"/>

  </android.support.v7.widget.CardView>

    class MaskedCardView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyle: Int = R.attr.materialCardViewStyle
) : MaterialCardView(context, attrs, defStyle) {
    @SuppressLint("RestrictedApi")
    private val pathProvider = ShapeAppearancePathProvider()
    private val path: Path = Path()
    private val shapeAppearance: ShapeAppearanceModel = ShapeAppearanceModel.builder(
        context,
        attrs,
        defStyle,
        R.style.Widget_MaterialComponents_CardView
    ).build()

    private val rectF = RectF(0f, 0f, 0f, 0f)

    override fun onDraw(canvas: Canvas) {
        canvas.clipPath(path)
        super.onDraw(canvas)
    }

    @SuppressLint("RestrictedApi")
    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        rectF.right = w.toFloat()
        rectF.bottom = h.toFloat()
        pathProvider.calculatePath(shapeAppearance, 1f, rectF, path)
        super.onSizeChanged(w, h, oldw, oldh)
    }
}