SIMPLEST APPROACH:

Create an xml file rounded_fg.xml under res/drawable/ folder of your app. The content of rounded_fg.xml is as follows,

<?xml version="1.0" encoding="UTF-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:innerRadiusRatio="2"
    android:shape="ring"
    android:thicknessRatio="1"
    android:useLevel="false">
    <gradient
        android:type="radial"
        android:gradientRadius="8dp"
        android:endColor="@color/white"
       />
</shape>

You can match endColor with ImageView container layout background & gradientRadius may be any value as per your requirements (<=36dp).

Now use this drawable as foreground for your imageview as follows,

 <ImageView
     android:layout_width="55dp"
     android:layout_height="55dp" 
     android:foreground="@drawable/rounded_fg" />

Works perfect with square images and/or imageview.

Square Image/ImageView:

Rectangular Image/ImageView:

Foreground applied over a button:

I use Universal Image loader library to download and round the corners of image, and it worked for me.

ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(thisContext)
            // You can pass your own memory cache implementation
           .discCacheFileNameGenerator(new HashCodeFileNameGenerator())
           .build();

DisplayImageOptions options = new DisplayImageOptions.Builder()
            .displayer(new RoundedBitmapDisplayer(10)) //rounded corner bitmap
            .cacheInMemory(true)
            .cacheOnDisc(true)
            .build();

ImageLoader imageLoader = ImageLoader.getInstance();
imageLoader.init(config);
imageLoader.displayImage(image_url,image_view, options );

you can do by XML like this way

<stroke android:width="3dp"
        android:color="#ff000000"/>

<padding android:left="1dp"
         android:top="1dp"
         android:right="1dp"
         android:bottom="1dp"/> 

<corners android:radius="30px"/> 

and pragmatically you can create rounded bitmap and set in ImageView.

public static Bitmap getRoundedCornerBitmap(Bitmap bitmap) {
Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
    bitmap.getHeight(), Config.ARGB_8888);
Canvas canvas = new Canvas(output);

final int color = 0xff424242;
final Paint paint = new Paint();
final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
final RectF rectF = new RectF(rect);
final float roundPx = 12;

paint.setAntiAlias(true);
canvas.drawARGB(0, 0, 0, 0);
paint.setColor(color);
canvas.drawRoundRect(rectF, roundPx, roundPx, paint);

paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
canvas.drawBitmap(bitmap, rect, rect, paint);

return output;
}

For Universal lazy loader you can use this wat also.

DisplayImageOptions options = new DisplayImageOptions.Builder()
        .displayer(new RoundedBitmapDisplayer(25)) // default
        .build();

NEW ANSWER
Use Glide library for this. This lib is also recommended by Google. See How to round an image with Glide library?

OLD ANSWER
Just add that image in a cardView and set cardView’s elevation on 0dp…will do the trick (in my case was a viewPager with images – just replace the viewPager with an ImageView):

<android.support.v7.widget.CardView
    android:layout_width="match_parent"
    android:layout_height="250dp"
    app:cardElevation="0dp">

    <android.support.v4.view.ViewPager
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/viewPager"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

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

You should use RoundedCornersTransformation from this library and create a circular ImageView.

import android.graphics.Bitmap; import android.graphics.BitmapShader; import android.graphics.Canvas; import android.graphics.Paint; import android.graphics.RectF; import android.graphics.Shader; import com.squareup.picasso.Transformation; public class RoundedCornersTransformation implements Transformation { public enum CornerType { ALL, TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT, TOP, BOTTOM, LEFT, RIGHT, OTHER_TOP_LEFT, OTHER_TOP_RIGHT, OTHER_BOTTOM_LEFT, OTHER_BOTTOM_RIGHT, DIAGONAL_FROM_TOP_LEFT, DIAGONAL_FROM_TOP_RIGHT } private int mRadius; private int mDiameter; private int mMargin; private CornerType mCornerType; public RoundedCornersTransformation(int radius, int margin) { this(radius, margin, CornerType.ALL); } public RoundedCornersTransformation(int radius, int margin, CornerType cornerType) { mRadius = radius; mDiameter = radius * 2; mMargin = margin; mCornerType = cornerType; } @Override public Bitmap transform(Bitmap source) { int width = source.getWidth(); int height = source.getHeight(); Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); Canvas canvas = new Canvas(bitmap); Paint paint = new Paint(); paint.setAntiAlias(true); paint.setShader(new BitmapShader(source, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP)); drawRoundRect(canvas, paint, width, height); source.recycle(); return bitmap; } private void drawRoundRect(Canvas canvas, Paint paint, float width, float height) { float right = width - mMargin; float bottom = height - mMargin; switch (mCornerType) { case ALL: canvas.drawRoundRect(new RectF(mMargin, mMargin, right, bottom), mRadius, mRadius, paint); break; case TOP_LEFT: drawTopLeftRoundRect(canvas, paint, right, bottom); break; case TOP_RIGHT: drawTopRightRoundRect(canvas, paint, right, bottom); break; case BOTTOM_LEFT: drawBottomLeftRoundRect(canvas, paint, right, bottom); break; case BOTTOM_RIGHT: drawBottomRightRoundRect(canvas, paint, right, bottom); break; case TOP: drawTopRoundRect(canvas, paint, right, bottom); break; case BOTTOM: drawBottomRoundRect(canvas, paint, right, bottom); break; case LEFT: drawLeftRoundRect(canvas, paint, right, bottom); break; case RIGHT: drawRightRoundRect(canvas, paint, right, bottom); break; case OTHER_TOP_LEFT: drawOtherTopLeftRoundRect(canvas, paint, right, bottom); break; case OTHER_TOP_RIGHT: drawOtherTopRightRoundRect(canvas, paint, right, bottom); break; case OTHER_BOTTOM_LEFT: drawOtherBottomLeftRoundRect(canvas, paint, right, bottom); break; case OTHER_BOTTOM_RIGHT: drawOtherBottomRightRoundRect(canvas, paint, right, bottom); break; case DIAGONAL_FROM_TOP_LEFT: drawDiagonalFromTopLeftRoundRect(canvas, paint, right, bottom); break; case DIAGONAL_FROM_TOP_RIGHT: drawDiagonalFromTopRightRoundRect(canvas, paint, right, bottom); break; default: canvas.drawRoundRect(new RectF(mMargin, mMargin, right, bottom), mRadius, mRadius, paint); break; } } private void drawTopLeftRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(mMargin, mMargin, mMargin + mDiameter, mMargin + mDiameter), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin + mRadius, mMargin + mRadius, bottom), paint); canvas.drawRect(new RectF(mMargin + mRadius, mMargin, right, bottom), paint); } private void drawTopRightRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(right - mDiameter, mMargin, right, mMargin + mDiameter), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin, right - mRadius, bottom), paint); canvas.drawRect(new RectF(right - mRadius, mMargin + mRadius, right, bottom), paint); } private void drawBottomLeftRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(mMargin, bottom - mDiameter, mMargin + mDiameter, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin, mMargin + mDiameter, bottom - mRadius), paint); canvas.drawRect(new RectF(mMargin + mRadius, mMargin, right, bottom), paint); } private void drawBottomRightRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(right - mDiameter, bottom - mDiameter, right, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin, right - mRadius, bottom), paint); canvas.drawRect(new RectF(right - mRadius, mMargin, right, bottom - mRadius), paint); } private void drawTopRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(mMargin, mMargin, right, mMargin + mDiameter), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin + mRadius, right, bottom), paint); } private void drawBottomRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(mMargin, bottom - mDiameter, right, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin, right, bottom - mRadius), paint); } private void drawLeftRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(mMargin, mMargin, mMargin + mDiameter, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin + mRadius, mMargin, right, bottom), paint); } private void drawRightRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(right - mDiameter, mMargin, right, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin, right - mRadius, bottom), paint); } private void drawOtherTopLeftRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(mMargin, bottom - mDiameter, right, bottom), mRadius, mRadius, paint); canvas.drawRoundRect(new RectF(right - mDiameter, mMargin, right, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin, right - mRadius, bottom - mRadius), paint); } private void drawOtherTopRightRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(mMargin, mMargin, mMargin + mDiameter, bottom), mRadius, mRadius, paint); canvas.drawRoundRect(new RectF(mMargin, bottom - mDiameter, right, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin + mRadius, mMargin, right, bottom - mRadius), paint); } private void drawOtherBottomLeftRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(mMargin, mMargin, right, mMargin + mDiameter), mRadius, mRadius, paint); canvas.drawRoundRect(new RectF(right - mDiameter, mMargin, right, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin + mRadius, right - mRadius, bottom), paint); } private void drawOtherBottomRightRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(mMargin, mMargin, right, mMargin + mDiameter), mRadius, mRadius, paint); canvas.drawRoundRect(new RectF(mMargin, mMargin, mMargin + mDiameter, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin + mRadius, mMargin + mRadius, right, bottom), paint); } private void drawDiagonalFromTopLeftRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(mMargin, mMargin, mMargin + mDiameter, mMargin + mDiameter), mRadius, mRadius, paint); canvas.drawRoundRect(new RectF(right - mDiameter, bottom - mDiameter, right, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin + mRadius, right - mDiameter, bottom), paint); canvas.drawRect(new RectF(mMargin + mDiameter, mMargin, right, bottom - mRadius), paint); } private void drawDiagonalFromTopRightRoundRect(Canvas canvas, Paint paint, float right, float bottom) { canvas.drawRoundRect(new RectF(right - mDiameter, mMargin, right, mMargin + mDiameter), mRadius, mRadius, paint); canvas.drawRoundRect(new RectF(mMargin, bottom - mDiameter, mMargin + mDiameter, bottom), mRadius, mRadius, paint); canvas.drawRect(new RectF(mMargin, mMargin, right - mRadius, bottom - mRadius), paint); canvas.drawRect(new RectF(mMargin + mRadius, mMargin + mRadius, right, bottom), paint); } @Override public String key() { return "RoundedTransformation(radius=" + mRadius + ", margin=" + mMargin + ", diameter=" + mDiameter + ", cornerType=" + mCornerType.name() + ")"; } } 

• May be you have found your solution but recently i found new library which allows you to create any many shape you want to set to the Image VIew.

  • Download the library from here
  • Define your Xml as :-
  • <com.makeramen.roundedimageview.RoundedImageView......... app:riv_corner_radius="Yourradiusdip"/>
  • And enjoy the coding.! this library i found is the best! thanks
    [I posted this answer later on but i recently used it and found it realy helpful]

Just wondering if anyone still needs it to be done.

For them: you can use RoundedBitmapDrawable for your purpose.

Sample Code:

ImageView profilePic = (ImageView) findViewById(R.idimageView); RoundedBitmapDrawable roundedBitmapDrawable = RoundedBitmapDrawableFactory.create(this.getResources(),bitmap); roundedBitmapDrawable.setCircular(true); profilePic.setImageDrawable(roundedBitmapDrawable); 

where bitmap is the image you want to load in imageView.

here is something I found from here: github

made a little improvising. Very simple and clean. No external files or methods:

public class RoundedImageView extends ImageView { private float mCornerRadius = 10.0f; public RoundedImageView(Context context) { super(context); } public RoundedImageView(Context context, AttributeSet attributes) { super(context, attributes); } @Override protected void onDraw(Canvas canvas) { // Round some corners betch! Drawable myDrawable = getDrawable(); if (myDrawable!=null && myDrawable instanceof BitmapDrawable && mCornerRadius > 0) { Paint paint = ((BitmapDrawable) myDrawable).getPaint(); final int color = 0xff000000; Rect bitmapBounds = myDrawable.getBounds(); final RectF rectF = new RectF(bitmapBounds); // Create an off-screen bitmap to the PorterDuff alpha blending to work right int saveCount = canvas.saveLayer(rectF, null, Canvas.MATRIX_SAVE_FLAG | Canvas.CLIP_SAVE_FLAG | Canvas.HAS_ALPHA_LAYER_SAVE_FLAG | Canvas.FULL_COLOR_LAYER_SAVE_FLAG | Canvas.CLIP_TO_LAYER_SAVE_FLAG); // Resize the rounded rect we'll clip by this view's current bounds // (super.onDraw() will do something similar with the drawable to draw) getImageMatrix().mapRect(rectF); paint.setAntiAlias(true); canvas.drawARGB(0, 0, 0, 0); paint.setColor(color); canvas.drawRoundRect(rectF, mCornerRadius, mCornerRadius, paint); Xfermode oldMode = paint.getXfermode(); // This is the paint already associated with the BitmapDrawable that super draws paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN)); super.onDraw(canvas); paint.setXfermode(oldMode); canvas.restoreToCount(saveCount); } else { super.onDraw(canvas); } } } 

its simple as possible by using this util method

/* * [email protected] imageView is your image you want to bordered it */ public static Bitmap generateBorders(ImageView imageView){ Bitmap mbitmap = ((BitmapDrawable) imageView.getDrawable()).getBitmap(); Bitmap imageRounded = Bitmap.createBitmap(mbitmap.getWidth(), mbitmap.getHeight(), mbitmap.getConfig()); Canvas canvas = new Canvas(imageRounded); Paint mpaint = new Paint(); mpaint.setAntiAlias(true); mpaint.setShader(new BitmapShader(mbitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP)); canvas.drawRoundRect((new RectF(0, 0, mbitmap.getWidth(), mbitmap.getHeight())), 100, 100, mpaint);// Round Image Corner 100 100 100 100 return imageRounded; } 

then set your image view bitmap with returned value have fun

Create a Drawable XML file

<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle"> <corners android:radius="8dp" /> <solid android:color="@android:color/white" /> <stroke android:width="1dp" android:color="@color/md_white_1000" /> 

In your layout you add the drawable as a background on the imageView.

 <ImageView android:layout_width="200dp" android:layout_height="200dp" android:src="@drawable/photo" android:background="@drawable/roundcorners"/> 

Then you add this line in your Java code.

ImageView.setClipToOutline(true); 

Note: this only works with level 21+

Now we no need to use any third party lib or custom imageView

Now We can use ShapeableImageView

SAMPLE CODE

First add below dependencies in your build.gradle file

implementation 'com.google.android.material:material:1.2.0-alpha05' 

Make ImageView Circular from coding

Add ShapeableImageView in your layout

<com.google.android.material.imageview.ShapeableImageView android:id="@+id/myShapeableImageView" android:layout_width="100dp" android:layout_height="100dp" android:layout_margin="20dp" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent" app:srcCompat="@drawable/nilesh" /> 

Kotlin code to make ImageView Circle

import androidx.appcompat.app.AppCompatActivity import android.os.Bundle import com.google.android.material.shape.CornerFamily import kotlinx.android.synthetic.main.activity_main.* class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // <dimen name="image_corner_radius">50dp</dimen> val radius = resources.getDimension(R.dimen.image_corner_radius) myShapeableImageView.shapeAppearanceModel = myShapeableImageView.shapeAppearanceModel .toBuilder() .setTopRightCorner(CornerFamily.ROUNDED, radius) .setTopLeftCorner(CornerFamily.ROUNDED, radius) .setBottomLeftCorner(CornerFamily.ROUNDED, radius) .setBottomRightCorner(CornerFamily.ROUNDED, radius) .build() // or You can use setAllCorners() method myShapeableImageView.shapeAppearanceModel = myShapeableImageView.shapeAppearanceModel .toBuilder() .setAllCorners(CornerFamily.ROUNDED, radius) .build() } } 

OUTPUT

Make ImageView Circle from using a style

First, create a below style in your style.xml

<style name="circleImageViewStyle" > <item name="cornerFamily">rounded</item> <item name="cornerSize">50%</item> </style> 

Now use that style in your layout like this

<com.google.android.material.imageview.ShapeableImageView android:id="@+id/myShapeableImageView" android:layout_width="100dp" android:layout_height="100dp" android:layout_margin="20dp" app:shapeAppearanceOverlay="@style/circleImageViewStyle" app:srcCompat="@drawable/nilesh" /> 

OUTPUT

Please find the complete exmaple here how to use ShapeableImageView

Try like this if you need to get rounded image ..

Your MainActivity.java class

public class MainActivity extends Activity { private static final int REQUEST_CODE = 1; private Bitmap bitmap; private ImageView imageView; Bitmap roundedBitmapImage; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); imageView = (ImageView) findViewById(R.id.result); } public void pickImage(View View) { Intent intent = new Intent(); intent.setType("image/*"); intent.setAction(Intent.ACTION_GET_CONTENT); intent.addCategory(Intent.CATEGORY_OPENABLE); startActivityForResult(intent, REQUEST_CODE); } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_CODE && resultCode == Activity.RESULT_OK) try { // We need to recycle unused bitmaps if (bitmap != null) { bitmap.recycle(); } InputStream stream = getContentResolver().openInputStream( data.getData()); bitmap = BitmapFactory.decodeStream(stream); stream.close(); /* Bitmap bitmap1=BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher); Bitmap bitmap2=BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher); Bitmap resultingImage=Bitmap.createBitmap(320, 480, bitmap1.getConfig()); Canvas canvas = new Canvas(resultingImage); Paint paint = new Paint(); paint.setAntiAlias(true); Path path=new Path(); path.lineTo(150, 0); path.lineTo(230, 120); path.lineTo(70, 120); path.lineTo(150, 0); canvas.drawPath(path, paint); paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN)); canvas.drawBitmap(bitmap2, 0, 0, paint);*/ //-------> compositeImageView.setImageBitmap(resultingImage); // Use this when to provide any shape to image i.e Fit image to any shape. // under mentioned taking reference from Rounder class. Finally changing image in round shape. // Here we are passing reference bitmap. roundedBitmapImage = new Rounder().getRoundedShape(bitmap); imageView.setImageBitmap(roundedBitmapImage); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } super.onActivityResult(requestCode, resultCode, data); } } 

And your rounder class ..

/** This class crops image to round shape */

public class Rounder { public Bitmap getRoundedShape(Bitmap scaleBitmapImage) { int targetWidth = 125; int targetHeight = 125; Bitmap targetBitmap = Bitmap.createBitmap(targetWidth, targetHeight, Bitmap.Config.ARGB_8888); Canvas canvas = new Canvas(targetBitmap); Path path = new Path(); path.addCircle(((float) targetWidth - 1) / 2, ((float) targetHeight - 1) / 2, (Math.min(((float) targetWidth), ((float) targetHeight)) / 2), Path.Direction.CCW); canvas.clipPath(path); Bitmap sourceBitmap = scaleBitmapImage; canvas.drawBitmap(sourceBitmap, new Rect(0, 0, sourceBitmap.getWidth(), sourceBitmap.getHeight()), new Rect(0, 0, targetWidth, targetHeight), null); return targetBitmap; } } 

found the easy way..
round imageview with user define radius:

http://shortcutsandroid.blogspot.in/2015/02/round-image-view-in-android.html

just add imageView.setRadius();

//it will set radius for the round imageView.

Use this Custom ImageView in Xml

public class RoundedCornerImageView extends ImageView { public RoundedCornerImageView(Context ctx, AttributeSet attrs) { super(ctx, attrs); } @Override protected void onDraw(Canvas canvas) { Drawable drawable = getDrawable(); if (drawable == null) { return; } if (getWidth() == 0 || getHeight() == 0) { return; } Bitmap b = ((BitmapDrawable) drawable).getBitmap(); Bitmap bitmap = b.copy(Bitmap.Config.ARGB_8888, true); int w = getWidth(), h = getHeight(); Bitmap roundBitmap = getRoundedCroppedBitmap(bitmap, w); canvas.drawBitmap(roundBitmap, 0, 0, null); } public static Bitmap getRoundedCroppedBitmap(Bitmap bitmap, int radius) { Bitmap finalBitmap; if (bitmap.getWidth() != radius || bitmap.getHeight() != radius) finalBitmap = Bitmap.createScaledBitmap(bitmap, radius, radius, false); else finalBitmap = bitmap; Bitmap output = Bitmap.createBitmap(finalBitmap.getWidth(), finalBitmap.getHeight(), Bitmap.Config.ARGB_8888); Canvas canvas = new Canvas(output); final Paint paint = new Paint(); final Rect rect = new Rect(0, 0, finalBitmap.getWidth(), finalBitmap.getHeight()); final RectF rectf = new RectF(0, 0, finalBitmap.getWidth(), finalBitmap.getHeight()); paint.setAntiAlias(true); paint.setFilterBitmap(true); paint.setDither(true); canvas.drawARGB(0, 0, 0, 0); paint.setColor(Color.parseColor("#BAB399")); //Set Required Radius Here int yourRadius = 7; canvas.drawRoundRect(rectf, yourRadius, yourRadius, paint); paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN)); canvas.drawBitmap(finalBitmap, rect, rect, paint); return output; } } 

Your MainActivity.java is like this:

LinearLayout ll = (LinearLayout) findViewById(R.id.ll); ImageView iv = (ImageView) findViewById(R.id.iv); 

You should to first get your image from Resource as Bitmap or Drawable.

If get as Bitmap:

Bitmap bm = BitmapFactory.decodeResource(getResources(), R.drawable.ash_arrow); bm = new Newreza().setEffect(bm, 0.2f, ((ColorDrawable) ll.getBackground).getColor); iv.setImageBitmap(bm); 

Or if get as Drawable:

Drawable d = getResources().getDrawable(R.drawable.ash_arrow); d = new Newreza().setEffect(d, 0.2f, ((ColorDrawable) ll.getBackground).getColor); iv.setImageDrawable(d); 

Then create new file as Newreza.java near MainActivity.java, and copy bottom codes in Newreza.java:

package your.package.name; import android.content.res.Resources; import android.graphics.Bitmap; import android.graphics.drawable.BitmapDrawable; import android.graphics.drawable.Drawable; //Telegram:@newreza //mail:[email protected] public class Newreza{ int a,x,y; float bmr; public Bitmap setEffect(Bitmap bm,float radius,int color){ bm=bm.copy(Bitmap.Config.ARGB_8888,true); bmr=radius*bm.getWidth(); for(y=0;y<bmr;y++){ a=(int)(bmr-Math.sqrt(y*(2*bmr-y))); for(x=0;x<a;x++){ bm.setPixel(x,y,color); } } for(y=0;y<bmr;y++){ a=(int)(bm.getWidth()-bmr+Math.sqrt(y*(2*bmr-y))); for(x=a;x<bm.getWidth();x++){ bm.setPixel(x,y,color); } } for(y=(int)(bm.getHeight()-bmr);y<bm.getHeight();y++){ a=(int)(bm.getWidth()-bmr+Math.sqrt(Math.pow(bmr,2)-Math.pow(bmr+y-bm.getHeight(),2))); for(x=a;x<bm.getWidth();x++){ bm.setPixel(x,y,color); } } for(y=(int)(bm.getHeight()-bmr);y<bm.getHeight();y++){ a=(int)(bmr-Math.sqrt(Math.pow(bmr,2)-Math.pow(bmr+y-bm.getHeight(),2))); for(x=0;x<a;x++){ bm.setPixel(x,y,color); } } return bm; } public Drawable setEffect(Drawable d,float radius,int color){ return new BitmapDrawable(Resources.getSystem(),setEffect(((BitmapDrawable)d).getBitmap(),radius,color)); } } 

Just notice that replace your package name with first line in the code.

It %100 works, because is written in details 🙂

I use extend ImageView:

public class RadiusCornerImageView extends android.support.v7.widget.AppCompatImageView { private int cornerRadiusDP = 0; // dp private int corner_radius_position; public RadiusCornerImageView(Context context) { super(context); } public RadiusCornerImageView(Context context, AttributeSet attrs) { super(context, attrs); } public RadiusCornerImageView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); TypedArray typeArray = context.getTheme().obtainStyledAttributes(attrs, R.styleable.RadiusCornerImageView, 0, 0); try { cornerRadiusDP = typeArray.getInt(R.styleable.RadiusCornerImageView_corner_radius_dp, 0); corner_radius_position = typeArray.getInteger(R.styleable.RadiusCornerImageView_corner_radius_position, 0); } finally { typeArray.recycle(); } } @Override protected void onDraw(Canvas canvas) { float radiusPx = AndroidUtil.dpToPx(getContext(), cornerRadiusDP); Path clipPath = new Path(); RectF rect = null; if (corner_radius_position == 0) { // all // round corners on all 4 angles rect = new RectF(0, 0, this.getWidth(), this.getHeight()); } else if (corner_radius_position == 1) { // round corners only on top left and top right rect = new RectF(0, 0, this.getWidth(), this.getHeight() + radiusPx); } else { throw new IllegalArgumentException("Unknown corner_radius_position = " + corner_radius_position); } clipPath.addRoundRect(rect, radiusPx, radiusPx, Path.Direction.CW); canvas.clipPath(clipPath); super.onDraw(canvas); } } 

Based on Nihal’s answer ( https://stackoverflow.com/a/42234152/2832027 ), here is a pure XML version that gives a rectangle with rounded corners on API 24 and above. On below API 24, it will show no rounded corners.

Usage:

<ImageView android:id="@+id/thumbnail" android:layout_width="150dp" android:layout_height="200dp" android:foreground="@drawable/rounded_corner_mask"/> 

rounded_corner_mask.xml

<?xml version="1.0" encoding="utf-8"?> <layer-list xmlns:android="http://schemas.android.com/apk/res/android"> <item android:gravity="bottom|right"> <vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="@dimen/rounding_radius" android:height="@dimen/rounding_radius" android:viewportWidth="10.0" android:viewportHeight="10.0"> <path android:pathData="M0,10 A10,10 0 0,0 10,0 L10,10 Z" android:fillColor="@color/white"/> </vector> </item> <item android:gravity="bottom|left"> <vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="@dimen/rounding_radius" android:height="@dimen/rounding_radius" android:viewportWidth="10.0" android:viewportHeight="10.0"> <path android:pathData="M0,0 A10,10 0 0,0 10,10 L0,10 Z" android:fillColor="@color/white"/> </vector> </item> <item android:gravity="top|left"> <vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="@dimen/rounding_radius" android:height="@dimen/rounding_radius" android:viewportWidth="10.0" android:viewportHeight="10.0"> <path android:pathData="M10,0 A10,10 0 0,0 0,10 L0,0 Z" android:fillColor="@color/white"/> </vector> </item> <item android:gravity="top|right"> <vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="@dimen/rounding_radius" android:height="@dimen/rounding_radius" android:viewportWidth="10.0" android:viewportHeight="10.0"> <path android:pathData="M10,10 A10,10 0 0,0 0,0 L10,0 Z" android:fillColor="@color/white"/> </vector> </item> </layer-list>