RoundImageView圆角矩形

最新推荐文章于 2024-06-14 09:45:18 发布
最新推荐文章于 2024-06-14 09:45:18 发布
阅读量844 收藏
点赞数
分类专栏： android 文章标签： android RoundedImageView 
</pre><pre>
</pre><pre name="code" class="java">********************************************RoundedImageView.java*****************************************

 

import android.content.Context;
import android.content.res.ColorStateList;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.LayerDrawable;
import android.net.Uri;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.ImageView;
import com.zumkum.starsworld.R;

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

  public static final String TAG = "RoundedImageView";
  public static final float DEFAULT_RADIUS = 0f;
  public static final float DEFAULT_BORDER_WIDTH = 0f;
  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 float cornerRadius = DEFAULT_RADIUS;
  private float borderWidth = DEFAULT_BORDER_WIDTH;
  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
  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) {
    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();
    }
  }

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

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

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

  public float getCornerRadius() {
    return cornerRadius;
  }

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

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

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

  public float getBorderWidth() {
    return borderWidth;
  }

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

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

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

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

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

  public ColorStateList getBorderColors() {
    return borderColor;
  }

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

  public boolean isOval() {
    return isOval;
  }

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

  public boolean mutatesBackground() {
    return mutateBackground;
  }

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

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

 

</pre><pre name="code" class="java">
 



 



 

***************************xml***************
 

<pre name="code" class="html">
 

 

<com.zumkum.starsworld.customview.RoundedImageView
                    android:layout_width="38dp" android:layout_height="38dp"
                    android:id="@+id/album_avatar"
                    app:corner_radius="10dp"
                    app:border_width="0.5dp"
                    app:border_color="@color/color_FF"
                    app:mutate_background="true"
                    app:oval="false"
                   android:scaleType="centerCrop"
                    android:contentDescription="@string/app_name"/>
 

 

 

 



 



 

</pre><p></p><p>**********************************************************RoundedDrawable.java*********************************************</p><p><pre name="code" class="java">

import android.content.res.ColorStateList;
import android.graphics.*;
import android.graphics.Bitmap.Config;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.LayerDrawable;
import android.util.Log;
import android.widget.ImageView.ScaleType;

@SuppressWarnings("UnusedDeclaration")
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(), 2);
    int height = Math.max(drawable.getIntrinsicHeight(), 2);
    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.reset();
        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.reset();

        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.reset();

        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.reset();
        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(float width) {
    mBorderWidth = width;
    mBorderPaint.setStrokeWidth(mBorderWidth);
    return this;
  }

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

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

  public ColorStateList getBorderColors() {
    return mBorderColor;
  }

  public RoundedDrawable setBorderColor(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_CENTER;
    }
    if (mScaleType != scaleType) {
      mScaleType = scaleType;
      updateShaderMatrix();
    }
    return this;
  }

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

 

 


 
 *******************************************************attrs************************************ 

 

<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="mutate_background" format="boolean" />
        <attr name="oval" format="boolean" />
        <attr name="android:scaleType" />
    </declare-styleable>

</resources>
 

 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  liye20110
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Android 自定义ImageView实现圆角图片，矩形圆角

				
			

			

				

					wangqing830414的专栏
				

				

					03-04
					
					546
					
				

			

		

		

			
				
方法一：BitmapShader方式首先简单了解下BitmapShader
BitmapShader是Shader的子类
Shader在三维软件中我们称之为着色器
通俗的理解，Shader的作用是给图像着色或者上色
BitmapShader允许我们载入一张图片来给图像着色
所以其实根据上面对于BitmapShader的描述
其实就可以对圆角ImageView有一定的思路了吧
画一个圆角矩形，然后把本来画上去的图像着色到圆角矩形上
这样就实现了圆角的ImageView


/**
 * @auth...

			
		

	



                

              
                



	

		

			

				
					
RoundImageView

				
			

			

				

					05-28
				

			

		

		

			
				
类似QQ头像，圆形的ImageView，自定义圆形ImageView，RoundImageView。

			
		

	



                


  
              

                


	

		

			

				
					
自定义ImageView实现圆角矩形

				
			

			

				

					七号公园的博客
				

				

					09-22
					
					4464
					
				

			

		

		

			
				
Android自带的imageView是矩形了，如果要自定义实现imageview的其他形状，如圆形。圆角矩形之类的。下面就来实现圆角矩形，
原理是：先取得图片的Bitmap，然后进行裁剪对应的圆角矩形的Bitmap,然后在onDraw()进行绘制圆角矩形。
先看源码：

package com.youle.bige.view;

import android.content.Contex

			
		

	





	

		

			

				
					
Android神话级圆形图片控件RoundImageView

					
热门推荐

				
			

			

				

					薄荷记账
				

				

					12-23
					
					1万+
					
				

			

		

		

			
				
RoundImageView是在不修改ImageView原有绘图逻辑的情况下实现的圆形特性，完全兼容ImageView的所有特性。
无论你的图像控件布局是什么样的，图像内容是什么样的，RoundImageView不圆不是英雄！
无论你的图像控件ScaleType是什么样的，矩阵转换MATRIX是什么样的，RoundImageView不圆不是传说！
无论你的控件或图像经过何种变换，比如内边距偏移，缩放，居中等等，你会发现一个圆紧紧的跟随着你的控件或图片，不离不弃，这就是神话级的圆形控件RoundImageVi

			
		

	



		

			
		



	

		

			

				
					
RoundImageView.java

				
			

			

				

					12-10
				

			

		

		

			
				
就是一个util的ImageView重写工具类，可以直接使用

			
		

	





	

		

			

				
					
RoundImageView圆角图片模糊锯齿问题

				
			

			

				

					苦逼程序员的笔记
				

				

					07-11
					
					2761
					
				

			

		

		

			
				
RoundImageView圆角图片模糊锯齿问题

使用RoundImageView时遇到了显示出来的圆角图片出现模糊锯齿的情况，而这种模糊只会在hdpi的机器上出现。

下面记录一下使用场景和出现问题的路径:


页面上有一张220x220的图片，源文件放在xxhdpi目录下
控件使用的是开源库RoundImageView
控件的宽高做了3种dpi设备的适配，xxhdpi目录下110dp，xhd...

			
		

	





	

		

			

				
					
Android 自定义 RoundImageView 实现圆角矩形或圆形图片

				
			

			

				

					云舒
				

				

					08-19
					
					1131
					
				

			

		

		

			
				
1、首先自定义一个RoundImageView，如下
package com.example.view;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.grap

			
		

	





	

		

			

				
					
RoundWidget:Java 实现的 Android 原生圆角矩形控件，圆角 FrameLayout 和圆角 ImageView

				
			

			

				

					05-07
				

			

		

		

			
				
Java 实现的 Android 原生圆角矩形控件，圆角 FrameLayout 和圆角 ImageView， 详见项目代码中的 RoundFrameLayout 和 RoundImageView。 更新日志 界面预览 使用 Gradle依赖： implementation '...

			
		

	





	

		

			

				
					
android imageview 图片圆角边框,Android应用自定义圆角图片RoundImageView

				
			

			

				

					weixin_42529544的博客
				

				

					05-26
					
					959
					
				

			

		

		

			
				
Android开发中图片控件ImageView默认的样子是矩形，方方正正的。在我们实际的项目中，有时候这些方正的图片显得有些呆板，我们就需要其它样式的图片，比较圆形图片(The rounded picture)， 常见的就是app中用户头像等。要得到圆形图片有很多方式，比如draw一个circle，也可以用切好的圆形图片做背景或者写一个xml实现圆角功能等 等。不过在项目中，如果我们有多个地方要把...

			
		

	





	

		

			

				
					
RoundedImageView:易于使用的轻巧的带有圆角的自定义图像视图

				
			

			

				

					03-31
				

			

		

		

			
				
RoundedImageView
 易于使用的带有圆角的轻型自定义图像视图。  ··
入门
要使此视图在您的应用上运行，请执行以下简单步骤。
1将JitPack存储库添加到您的项目级别的build.gradle文件中
allprojects {
  repositories {
    ...
    maven { url 'https://jitpack.io' }
  }
}
2将依赖项添加到模块级别的build.gradle文件中
dependencies {
  implementation 'com.github.mmmelik:RoundedImageView:v1.0.0'
}
用法
使用此空间来显示有关如何使用项目的有用示例。 在此空间中，其他屏幕截图，代码示例和演示也可以正常工作。 您也可以链接到更多资源。
 有关更多示例，请参阅
路线图
有关建议的功能（和已知问题）列

			
		

	





	

		

			

				
					
CornerImageView  实现圆角图片

				
			

			

				

					09-04
				

			

		

		

			
				
该demo主要是对ImageView做了一些美化，实现了ImageView的圆角，里面还用到了自定View的一些技术，而且还对ImageView进行了描边，是一个比较美的界面。

			
		

	





	

		

			

				
					
圆角矩形和圆形ImageView的实现

				
			

			

				

					08-23
				

			

		

		

			
				
http://blog.csdn.net/huaxun66/article/details/52269547

			
		

	





	

		

			

				
					
Android代码-RoundImageView

				
			

			

				

					08-06
				

			

		

		

			
				
RoundImageView

圆角图片控件，支持圆形边框和椭圆边框
ScreenShot

Usage
Gradle:
compile 'com.wx.ovalimageview:roundimageview:1.1.0'
Maven:

  com.wx.ovalimageview
  roundimageview
  1.1.0
  pom

导入Eclipse(只能使用Java代码设置参数):
下载jar包
Demo
Use the RoundImageView as a View, Java and XML are both supported.
Java:
    public class MainActivity extends Activity {
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.

			
		

	





	

		

			

				
					
RoundImageView加载网络图片

				
			

			

				

					12-29
				

			

		

		

			
				
此源码是修改的http://blog.csdn.net/lmj623565791/article/details/41967509的RoundImageView，因为他的圆形图片无法加载网络图片，因此我做了些许修改，希望能帮到大家，如果有不对地方还请指出。

			
		

	





	

		

			

				
					
圆形头像（RoundImageView）

				
			

			

				

					戏耍明天的专栏
				

				

					07-13
					
					536
					
				

			

		

		

			
				
自定义圆形头像ImageView


public class RoundImageView extends ImageView {

    private Bitmap mCircleBitmap;
    private Canvas mCanvas;
    private Paint mPaint;

    public RoundImageView(Context contex

			
		

	





	

		

			

				
					
工具篇——RoundImageView（圆形的ImageView）

				
			

			

				

					一个灵活的胖子MrWang
				

				

					05-09
					
					1952
					
				

			

		

		

			
				
写代码的四点：  1.明确需求。要做什么？  2.分析思路。要怎么做？（1,2,3……）  3.确定步骤。每一个思路要用到哪些语句、方法和对象。  4.代码实现。用具体的语言代码将思路实现出来。学习新技术的四点：  1.该技术是什么？  2.该技术有什么特点？（使用需注意的方面）  3.该技术怎么使用？（写Demo）  4.该技术什么时候用？（在Pr...

			
		

	





	

		

			

				
					
推荐使用：RoundImageView —— 实现圆角图片的完美解决方案

					
最新发布

				
			

			

				

					gitblog_00095的博客
				

				

					06-14
					
					455
					
				

			

		

		

			
				
推荐使用：RoundImageView —— 实现圆角图片的完美解决方案
 RoundImageViewA Round ImageView that works with vectors!项目地址:https://gitcode.com/gh_mirrors/ro/RoundImageView 1、项目介绍
在开发Android应用时，我们经常需要创建圆形或者带有边框的圆形头像等元素，以提升界面的...

			
		

	





	

		

			

				
					
自定义view之RoundImageView

				
			

			

				

					li15225271052的博客
				

				

					02-20
					
					637
					
				

			

		

		

			
				
最近，会遇到将图片以圆或者圆角的形式展示的需求，索性就写一个 
这里直接贴出代码（有空的时候，完成其他的几个的了解之后写个详细解释） 
首先是attrs<?xml version="1.0" encoding="utf-8"?>
<resources>
    <attr name="borderRadius" format="dimension" />
    <attr name="type">

			
		

	





	

		

			

				
					
HTML5 Canvas圆角矩形绘制与2048游戏与微信对话框实例

				
			

			

				

					
				

			

		

		

			
				
圆角矩形是Canvas中的基本元素之一，通过结合直线和弧线绘制而成，其形状由四个边和四个半径为`radius`的圆弧组成。  作者首先提供了一个HTML结构，设置了页面背景和一个800x600像素的Canvas元素，用于展示绘制结果...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值